From 35920d8605548ef9fedfa098c8cac874b191ad47 Mon Sep 17 00:00:00 2001 From: pjh456 <147148383@qq.com> Date: Tue, 13 Oct 2026 17:36:47 +0000 Subject: [PATCH] =?UTF-8?q?style:=20=E8=87=AA=E5=8A=A8=E6=A0=BC=E5=BC=8F?= =?UTF-8?q?=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- crates/oxide_emit/src/module.rs | 120 ++++++------------- crates/oxide_emit/tests/module_link_tests.rs | 57 ++------- crates/oxide_vm/src/promise/aggregate.rs | 4 +- 3 files changed, 53 insertions(+), 128 deletions(-) diff --git a/crates/oxide_emit/src/module.rs b/crates/oxide_emit/src/module.rs index 0c70db81..b643cf17 100644 --- a/crates/oxide_emit/src/module.rs +++ b/crates/oxide_emit/src/module.rs @@ -23,11 +23,10 @@ use oxide_ir::inst::Inst; use oxide_ir::operand::Operand; use oxide_ir::{IRFunction, ParamLayout}; use oxide_parser::{ - ArrayExpressionElement, AssignmentTarget, AssignmentTargetMaybeDefault, AssignmentTargetProperty, - BindingPattern, ChainElement, Declaration, ExportDefaultDeclarationKind, Expression, - ForStatementInit, ForStatementLeft, ImportAttributeKey, ImportDeclarationSpecifier, ImportPhase, - ModuleExportName, ObjectPropertyKind, SimpleAssignmentTarget, Statement, VariableDeclarationKind, - WithClause, + ArrayExpressionElement, AssignmentTarget, AssignmentTargetMaybeDefault, AssignmentTargetProperty, BindingPattern, + ChainElement, Declaration, ExportDefaultDeclarationKind, Expression, ForStatementInit, ForStatementLeft, + ImportAttributeKey, ImportDeclarationSpecifier, ImportPhase, ModuleExportName, ObjectPropertyKind, + SimpleAssignmentTarget, Statement, VariableDeclarationKind, WithClause, }; use oxide_types::MODULE_NAMESPACE_BINDING; @@ -355,15 +354,10 @@ fn module_has_top_level_await(body: &[Statement]) -> bool { /// 语句级顶层 `await` 游走：进入子语句与子表达式，函数/类声明体不进入。 fn stmt_has_top_level_await(stmt: &Statement) -> bool { match stmt { - Statement::BlockStatement(block) => { - block.body.iter().any(|s| stmt_has_top_level_await(s)) - } + Statement::BlockStatement(block) => block.body.iter().any(|s| stmt_has_top_level_await(s)), Statement::IfStatement(if_stmt) => { stmt_has_top_level_await(&if_stmt.consequent) - || if_stmt - .alternate - .as_ref() - .is_some_and(|alt| stmt_has_top_level_await(alt)) + || if_stmt.alternate.as_ref().is_some_and(|alt| stmt_has_top_level_await(alt)) } Statement::ForStatement(for_stmt) => { for_stmt.init.as_ref().is_some_and(|init| match init { @@ -372,10 +366,9 @@ fn stmt_has_top_level_await(stmt: &Statement) -> bool { .iter() .any(|d| d.init.as_ref().is_some_and(|i| expr_has_top_level_await(i))), _ => init.as_expression().is_some_and(expr_has_top_level_await), - }) - || for_stmt.test.as_ref().is_some_and(|t| expr_has_top_level_await(t)) - || for_stmt.update.as_ref().is_some_and(|u| expr_has_top_level_await(u)) - || stmt_has_top_level_await(&for_stmt.body) + }) || for_stmt.test.as_ref().is_some_and(|t| expr_has_top_level_await(t)) + || for_stmt.update.as_ref().is_some_and(|u| expr_has_top_level_await(u)) + || stmt_has_top_level_await(&for_stmt.body) } Statement::ForInStatement(for_in) => { for_left_has_top_level_await(&for_in.left) @@ -420,10 +413,7 @@ fn stmt_has_top_level_await(stmt: &Statement) -> bool { expr_has_top_level_await(&with_stmt.object) || stmt_has_top_level_await(&with_stmt.body) } Statement::ExpressionStatement(expr_stmt) => expr_has_top_level_await(&expr_stmt.expression), - Statement::ReturnStatement(ret) => ret - .argument - .as_ref() - .is_some_and(|a| expr_has_top_level_await(a)), + Statement::ReturnStatement(ret) => ret.argument.as_ref().is_some_and(|a| expr_has_top_level_await(a)), Statement::ThrowStatement(throw) => expr_has_top_level_await(&throw.argument), Statement::VariableDeclaration(vd) => vd .declarations @@ -452,32 +442,23 @@ fn for_left_has_top_level_await(left: &ForStatementLeft) -> bool { /// 成员、TS 包装）经 `simple_target_has_top_level_await` 游走。 fn target_has_top_level_await(target: &AssignmentTarget) -> bool { match target { - AssignmentTarget::ArrayAssignmentTarget(arr) => arr - .elements - .iter() - .flatten() - .any(|e| target_maybe_default_has_top_level_await(e)) - || arr - .rest - .as_ref() - .is_some_and(|r| target_has_top_level_await(&r.target)), + AssignmentTarget::ArrayAssignmentTarget(arr) => { + arr.elements + .iter() + .flatten() + .any(|e| target_maybe_default_has_top_level_await(e)) + || arr.rest.as_ref().is_some_and(|r| target_has_top_level_await(&r.target)) + } AssignmentTarget::ObjectAssignmentTarget(obj) => { obj.properties.iter().any(|p| match p { - AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(id) => id - .init - .as_ref() - .is_some_and(|i| expr_has_top_level_await(i)), + AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(id) => { + id.init.as_ref().is_some_and(|i| expr_has_top_level_await(i)) + } AssignmentTargetProperty::AssignmentTargetPropertyProperty(prop) => { - prop.name - .as_expression() - .is_some_and(expr_has_top_level_await) + prop.name.as_expression().is_some_and(expr_has_top_level_await) || target_maybe_default_has_top_level_await(&prop.binding) } - }) - || obj - .rest - .as_ref() - .is_some_and(|r| target_has_top_level_await(&r.target)) + }) || obj.rest.as_ref().is_some_and(|r| target_has_top_level_await(&r.target)) } _ => target .as_simple_assignment_target() @@ -549,32 +530,19 @@ fn expr_has_top_level_await(expr: &Expression) -> bool { Expression::StaticMemberExpression(m) => expr_has_top_level_await(&m.object), Expression::PrivateFieldExpression(m) => expr_has_top_level_await(&m.object), Expression::ChainExpression(chain) => chain_element_has_top_level_await(&chain.expression), - Expression::ArrayExpression(arr) => arr - .elements - .iter() - .any(|e| match e { - ArrayExpressionElement::SpreadElement(spread) => { - expr_has_top_level_await(&spread.argument) - } - _ => e.as_expression().is_some_and(expr_has_top_level_await), - }), + Expression::ArrayExpression(arr) => arr.elements.iter().any(|e| match e { + ArrayExpressionElement::SpreadElement(spread) => expr_has_top_level_await(&spread.argument), + _ => e.as_expression().is_some_and(expr_has_top_level_await), + }), Expression::ObjectExpression(obj) => obj.properties.iter().any(|p| match p { ObjectPropertyKind::ObjectProperty(prop) => { - (prop.computed - && prop - .key - .as_expression() - .is_some_and(expr_has_top_level_await)) + (prop.computed && prop.key.as_expression().is_some_and(expr_has_top_level_await)) || expr_has_top_level_await(&prop.value) } ObjectPropertyKind::SpreadProperty(spread) => expr_has_top_level_await(&spread.argument), }), - Expression::SequenceExpression(seq) => { - seq.expressions.iter().any(|e| expr_has_top_level_await(e)) - } - Expression::TemplateLiteral(tmpl) => { - tmpl.expressions.iter().any(|e| expr_has_top_level_await(e)) - } + Expression::SequenceExpression(seq) => seq.expressions.iter().any(|e| expr_has_top_level_await(e)), + Expression::TemplateLiteral(tmpl) => tmpl.expressions.iter().any(|e| expr_has_top_level_await(e)), Expression::TaggedTemplateExpression(tagged) => { expr_has_top_level_await(&tagged.tag) || tagged.quasi.expressions.iter().any(|e| expr_has_top_level_await(e)) @@ -583,27 +551,21 @@ fn expr_has_top_level_await(expr: &Expression) -> bool { Expression::AssignmentExpression(assign) => { target_has_top_level_await(&assign.left) || expr_has_top_level_await(&assign.right) } - Expression::UpdateExpression(update) => { - simple_target_has_top_level_await(&update.argument) - } + Expression::UpdateExpression(update) => simple_target_has_top_level_await(&update.argument), Expression::UnaryExpression(unary) => expr_has_top_level_await(&unary.argument), Expression::ParenthesizedExpression(paren) => expr_has_top_level_await(&paren.expression), - Expression::YieldExpression(yield_expr) => yield_expr - .argument - .as_ref() - .is_some_and(|a| expr_has_top_level_await(a)), + Expression::YieldExpression(yield_expr) => { + yield_expr.argument.as_ref().is_some_and(|a| expr_has_top_level_await(a)) + } Expression::PrivateInExpression(private_in) => expr_has_top_level_await(&private_in.right), Expression::ImportExpression(import_expr) => { expr_has_top_level_await(&import_expr.source) - || import_expr - .options - .as_ref() - .is_some_and(|o| expr_has_top_level_await(o)) + || import_expr.options.as_ref().is_some_and(|o| expr_has_top_level_await(o)) } // 函数体：独立异步语义边界，不进入。 - Expression::FunctionExpression(_) - | Expression::ArrowFunctionExpression(_) - | Expression::ClassExpression(_) => false, + Expression::FunctionExpression(_) | Expression::ArrowFunctionExpression(_) | Expression::ClassExpression(_) => { + false + } // 字面量/标识符/this/super/meta 等无子表达式。 _ => false, } @@ -623,12 +585,8 @@ fn chain_element_has_top_level_await(element: &ChainElement) -> bool { ChainElement::ComputedMemberExpression(computed) => { expr_has_top_level_await(&computed.object) || expr_has_top_level_await(&computed.expression) } - ChainElement::StaticMemberExpression(static_member) => { - expr_has_top_level_await(&static_member.object) - } - ChainElement::PrivateFieldExpression(private_field) => { - expr_has_top_level_await(&private_field.object) - } + ChainElement::StaticMemberExpression(static_member) => expr_has_top_level_await(&static_member.object), + ChainElement::PrivateFieldExpression(private_field) => expr_has_top_level_await(&private_field.object), } } diff --git a/crates/oxide_emit/tests/module_link_tests.rs b/crates/oxide_emit/tests/module_link_tests.rs index ded357de..c59cc81d 100644 --- a/crates/oxide_emit/tests/module_link_tests.rs +++ b/crates/oxide_emit/tests/module_link_tests.rs @@ -478,12 +478,8 @@ fn no_defer_object_for_non_defer_modules() { /// 无异步依赖时不发聚合 gate。 #[test] fn tla_module_compiles_async_without_gate() { - let (ir, _) = emit_module( - "const x = await Promise.resolve(1); export { x };", - "./entry.js", - &[], - ) - .expect("TLA 模块应编译成功"); + let (ir, _) = emit_module("const x = await Promise.resolve(1); export { x };", "./entry.js", &[]) + .expect("TLA 模块应编译成功"); assert!(ir.is_async, "含顶层 await 的模块应标记异步求值"); assert_eq!( ir.insts.iter().filter(|i| i.op == OpCode::AWAIT).count(), @@ -497,48 +493,29 @@ fn tla_module_compiles_async_without_gate() { /// 异步函数体内的 await 不使模块变异步（await 落在嵌套子模块）。 #[test] fn non_tla_module_stays_sync() { - let (ir, _) = emit_module( - "async function f() { return await Promise.resolve(1); } export { f };", - "./entry.js", - &[], - ) - .expect("非 TLA 模块应编译成功"); + let (ir, _) = + emit_module("async function f() { return await Promise.resolve(1); } export { f };", "./entry.js", &[]) + .expect("非 TLA 模块应编译成功"); assert!(!ir.is_async, "无顶层 await 的模块不得标记异步"); - assert_eq!( - ir.insts.iter().filter(|i| i.op == OpCode::AWAIT).count(), - 0, - "主身不得含 AWAIT" - ); + assert_eq!(ir.insts.iter().filter(|i| i.op == OpCode::AWAIT).count(), 0, "主身不得含 AWAIT"); } /// 面 21：`for await…of` 在模块代码使模块异步（规范强制模块异步求值， /// `await` 关键字触发 [[HasTLA]]；右值与体照常游走）。 #[test] fn for_await_of_makes_module_async() { - let (ir, _) = emit_module( - "for await (const x of iter) { globalThis.v = x; }", - "./entry.js", - &[], - ) - .expect("for await…of 模块应编译成功"); + let (ir, _) = emit_module("for await (const x of iter) { globalThis.v = x; }", "./entry.js", &[]) + .expect("for await…of 模块应编译成功"); assert!(ir.is_async, "for await…of 应使模块标记异步"); } /// 面 22：普通 `for…of`（无 `await`）不使模块异步，主身零 AWAIT。 #[test] fn for_of_is_not_tla() { - let (ir, _) = emit_module( - "for (const x of iter) { globalThis.v = x; }", - "./entry.js", - &[], - ) - .expect("for…of 模块应编译成功"); + let (ir, _) = + emit_module("for (const x of iter) { globalThis.v = x; }", "./entry.js", &[]).expect("for…of 模块应编译成功"); assert!(!ir.is_async, "普通 for…of 不得使模块标记异步"); - assert_eq!( - ir.insts.iter().filter(|i| i.op == OpCode::AWAIT).count(), - 0, - "主身不得含 AWAIT" - ); + assert_eq!(ir.insts.iter().filter(|i| i.op == OpCode::AWAIT).count(), 0, "主身不得含 AWAIT"); } /// 面 23：异步 eager 依赖聚合 gate——依赖含顶层 `await` 时 `__moduleEval` 返回 @@ -553,11 +530,7 @@ fn async_dep_emits_wait_all_gate() { .expect("含异步依赖的模块应编译成功"); assert!(ir.is_async, "含异步依赖的导入方应标记异步求值"); assert_eq!(native_calls_to(&ir, "__moduleWaitAll"), 1, "聚合 gate 应发一次"); - assert_eq!( - ir.insts.iter().filter(|i| i.op == OpCode::AWAIT).count(), - 1, - "gate 应以单 AWAIT 挂起" - ); + assert_eq!(ir.insts.iter().filter(|i| i.op == OpCode::AWAIT).count(), 1, "gate 应以单 AWAIT 挂起"); } /// 面 24：同步依赖零 diff 守卫——无 gate、无 AWAIT、模块保持同步。 @@ -571,9 +544,5 @@ fn sync_dep_no_gate() { .expect("含同步依赖的模块应编译成功"); assert!(!ir.is_async, "无顶层 await 且依赖同步的模块不得标记异步"); assert_eq!(native_calls_to(&ir, "__moduleWaitAll"), 0, "同步依赖不得发聚合 gate"); - assert_eq!( - ir.insts.iter().filter(|i| i.op == OpCode::AWAIT).count(), - 0, - "主身不得含 AWAIT" - ); + assert_eq!(ir.insts.iter().filter(|i| i.op == OpCode::AWAIT).count(), 0, "主身不得含 AWAIT"); } diff --git a/crates/oxide_vm/src/promise/aggregate.rs b/crates/oxide_vm/src/promise/aggregate.rs index e0ed62cb..3798c889 100644 --- a/crates/oxide_vm/src/promise/aggregate.rs +++ b/crates/oxide_vm/src/promise/aggregate.rs @@ -184,9 +184,7 @@ impl Vm { promises.push(self.reg(args[i + 1])); } let array = self.make_plain_array(promises); - let ctor = JsValue::from_js_object( - self.realm.promise_constructor.borrow().as_ptr() as *mut JsObject, - ); + let ctor = JsValue::from_js_object(self.realm.promise_constructor.borrow().as_ptr() as *mut JsObject); match perform_promise_combine(self, ctor, array, AggregateKind::All) { Ok(promise) => NativeResult::Ok(promise), Err(err) => NativeResult::Err(err),