ITStudio_OUC/OxideJS-New
0
1
Fork 0
mirror of https://github.com/pjh456/OxideJS.git synced 2026-10-26 11:41:13 +08:00
Code Issues Packages Projects Releases Wiki Activity

style: 自动格式化

Browse Source
This commit is contained in:
彭俊皓
2026-10-13 17:36:47 +00:00
parent 75cece2ad9
commit 35920d8605
3 changed files with 53 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/oxide_emit/src/module.rs
+39 -81
View File
@@ -23,11 +23,10 @@ use oxide_ir::inst::Inst;
use oxide_ir::operand::Operand; use oxide_ir::operand::Operand;
use oxide_ir::{IRFunction, ParamLayout}; use oxide_ir::{IRFunction, ParamLayout};
use oxide_parser::{ use oxide_parser::{
ArrayExpressionElement, AssignmentTarget, AssignmentTargetMaybeDefault, AssignmentTargetProperty, ArrayExpressionElement, AssignmentTarget, AssignmentTargetMaybeDefault, AssignmentTargetProperty, BindingPattern,
BindingPattern, ChainElement, Declaration, ExportDefaultDeclarationKind, Expression, ChainElement, Declaration, ExportDefaultDeclarationKind, Expression, ForStatementInit, ForStatementLeft,
ForStatementInit, ForStatementLeft, ImportAttributeKey, ImportDeclarationSpecifier, ImportPhase, ImportAttributeKey, ImportDeclarationSpecifier, ImportPhase, ModuleExportName, ObjectPropertyKind,
ModuleExportName, ObjectPropertyKind, SimpleAssignmentTarget, Statement, VariableDeclarationKind, SimpleAssignmentTarget, Statement, VariableDeclarationKind, WithClause,
WithClause,
}; };
use oxide_types::MODULE_NAMESPACE_BINDING; use oxide_types::MODULE_NAMESPACE_BINDING;
@@ -355,15 +354,10 @@ fn module_has_top_level_await(body: &[Statement]) -> bool {
/// 语句级顶层 `await` 游走：进入子语句与子表达式，函数/类声明体不进入。 /// 语句级顶层 `await` 游走：进入子语句与子表达式，函数/类声明体不进入。
fn stmt_has_top_level_await(stmt: &Statement) -> bool { fn stmt_has_top_level_await(stmt: &Statement) -> bool {
match stmt { match stmt {
Statement::BlockStatement(block) => { Statement::BlockStatement(block) => block.body.iter().any(|s| stmt_has_top_level_await(s)),
block.body.iter().any(|s| stmt_has_top_level_await(s))
}
Statement::IfStatement(if_stmt) => { Statement::IfStatement(if_stmt) => {
stmt_has_top_level_await(&if_stmt.consequent) stmt_has_top_level_await(&if_stmt.consequent)
|| if_stmt || if_stmt.alternate.as_ref().is_some_and(|alt| stmt_has_top_level_await(alt))
.alternate
.as_ref()
.is_some_and(|alt| stmt_has_top_level_await(alt))
} }
Statement::ForStatement(for_stmt) => { Statement::ForStatement(for_stmt) => {
for_stmt.init.as_ref().is_some_and(|init| match init { 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() .iter()
.any(|d| d.init.as_ref().is_some_and(|i| expr_has_top_level_await(i))), .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), _ => 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.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))
|| for_stmt.update.as_ref().is_some_and(|u| expr_has_top_level_await(u)) || stmt_has_top_level_await(&for_stmt.body)
|| stmt_has_top_level_await(&for_stmt.body)
} }
Statement::ForInStatement(for_in) => { Statement::ForInStatement(for_in) => {
for_left_has_top_level_await(&for_in.left) 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) 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::ExpressionStatement(expr_stmt) => expr_has_top_level_await(&expr_stmt.expression),
Statement::ReturnStatement(ret) => ret Statement::ReturnStatement(ret) => ret.argument.as_ref().is_some_and(|a| expr_has_top_level_await(a)),
.argument
.as_ref()
.is_some_and(|a| expr_has_top_level_await(a)),
Statement::ThrowStatement(throw) => expr_has_top_level_await(&throw.argument), Statement::ThrowStatement(throw) => expr_has_top_level_await(&throw.argument),
Statement::VariableDeclaration(vd) => vd Statement::VariableDeclaration(vd) => vd
.declarations .declarations
@@ -452,32 +442,23 @@ fn for_left_has_top_level_await(left: &ForStatementLeft) -> bool {
/// 成员、TS 包装）经 `simple_target_has_top_level_await` 游走。 /// 成员、TS 包装）经 `simple_target_has_top_level_await` 游走。
fn target_has_top_level_await(target: &AssignmentTarget) -> bool { fn target_has_top_level_await(target: &AssignmentTarget) -> bool {
match target { match target {
AssignmentTarget::ArrayAssignmentTarget(arr) => arr AssignmentTarget::ArrayAssignmentTarget(arr) => {
.elements arr.elements
.iter() .iter()
.flatten() .flatten()
.any(|e| target_maybe_default_has_top_level_await(e)) .any(|e| target_maybe_default_has_top_level_await(e))
|| arr || arr.rest.as_ref().is_some_and(|r| target_has_top_level_await(&r.target))
.rest }
.as_ref()
.is_some_and(|r| target_has_top_level_await(&r.target)),
AssignmentTarget::ObjectAssignmentTarget(obj) => { AssignmentTarget::ObjectAssignmentTarget(obj) => {
obj.properties.iter().any(|p| match p { obj.properties.iter().any(|p| match p {
AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(id) => id AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(id) => {
.init id.init.as_ref().is_some_and(|i| expr_has_top_level_await(i))
.as_ref() }
.is_some_and(|i| expr_has_top_level_await(i)),
AssignmentTargetProperty::AssignmentTargetPropertyProperty(prop) => { AssignmentTargetProperty::AssignmentTargetPropertyProperty(prop) => {
prop.name prop.name.as_expression().is_some_and(expr_has_top_level_await)
.as_expression()
.is_some_and(expr_has_top_level_await)
|| target_maybe_default_has_top_level_await(&prop.binding) || 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 _ => target
.as_simple_assignment_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::StaticMemberExpression(m) => expr_has_top_level_await(&m.object),
Expression::PrivateFieldExpression(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::ChainExpression(chain) => chain_element_has_top_level_await(&chain.expression),
Expression::ArrayExpression(arr) => arr Expression::ArrayExpression(arr) => arr.elements.iter().any(|e| match e {
.elements ArrayExpressionElement::SpreadElement(spread) => expr_has_top_level_await(&spread.argument),
.iter() _ => e.as_expression().is_some_and(expr_has_top_level_await),
.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 { Expression::ObjectExpression(obj) => obj.properties.iter().any(|p| match p {
ObjectPropertyKind::ObjectProperty(prop) => { ObjectPropertyKind::ObjectProperty(prop) => {
(prop.computed (prop.computed && prop.key.as_expression().is_some_and(expr_has_top_level_await))
&& prop
.key
.as_expression()
.is_some_and(expr_has_top_level_await))
|| expr_has_top_level_await(&prop.value) || expr_has_top_level_await(&prop.value)
} }
ObjectPropertyKind::SpreadProperty(spread) => expr_has_top_level_await(&spread.argument), ObjectPropertyKind::SpreadProperty(spread) => expr_has_top_level_await(&spread.argument),
}), }),
Expression::SequenceExpression(seq) => { Expression::SequenceExpression(seq) => seq.expressions.iter().any(|e| expr_has_top_level_await(e)),
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::TemplateLiteral(tmpl) => {
tmpl.expressions.iter().any(|e| expr_has_top_level_await(e))
}
Expression::TaggedTemplateExpression(tagged) => { Expression::TaggedTemplateExpression(tagged) => {
expr_has_top_level_await(&tagged.tag) expr_has_top_level_await(&tagged.tag)
|| tagged.quasi.expressions.iter().any(|e| expr_has_top_level_await(e)) || 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) => { Expression::AssignmentExpression(assign) => {
target_has_top_level_await(&assign.left) || expr_has_top_level_await(&assign.right) target_has_top_level_await(&assign.left) || expr_has_top_level_await(&assign.right)
} }
Expression::UpdateExpression(update) => { Expression::UpdateExpression(update) => simple_target_has_top_level_await(&update.argument),
simple_target_has_top_level_await(&update.argument)
}
Expression::UnaryExpression(unary) => expr_has_top_level_await(&unary.argument), Expression::UnaryExpression(unary) => expr_has_top_level_await(&unary.argument),
Expression::ParenthesizedExpression(paren) => expr_has_top_level_await(&paren.expression), Expression::ParenthesizedExpression(paren) => expr_has_top_level_await(&paren.expression),
Expression::YieldExpression(yield_expr) => yield_expr Expression::YieldExpression(yield_expr) => {
.argument yield_expr.argument.as_ref().is_some_and(|a| expr_has_top_level_await(a))
.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::PrivateInExpression(private_in) => expr_has_top_level_await(&private_in.right),
Expression::ImportExpression(import_expr) => { Expression::ImportExpression(import_expr) => {
expr_has_top_level_await(&import_expr.source) expr_has_top_level_await(&import_expr.source)
|| import_expr || import_expr.options.as_ref().is_some_and(|o| expr_has_top_level_await(o))
.options
.as_ref()
.is_some_and(|o| expr_has_top_level_await(o))
} }
// 函数体：独立异步语义边界，不进入。 // 函数体：独立异步语义边界，不进入。
Expression::FunctionExpression(_) Expression::FunctionExpression(_) | Expression::ArrowFunctionExpression(_) | Expression::ClassExpression(_) => {
| Expression::ArrowFunctionExpression(_) false
| Expression::ClassExpression(_) => false, }
// 字面量/标识符/this/super/meta 等无子表达式。 // 字面量/标识符/this/super/meta 等无子表达式。
_ => false, _ => false,
} }
@@ -623,12 +585,8 @@ fn chain_element_has_top_level_await(element: &ChainElement) -> bool {
ChainElement::ComputedMemberExpression(computed) => { ChainElement::ComputedMemberExpression(computed) => {
expr_has_top_level_await(&computed.object) || expr_has_top_level_await(&computed.expression) expr_has_top_level_await(&computed.object) || expr_has_top_level_await(&computed.expression)
} }
ChainElement::StaticMemberExpression(static_member) => { ChainElement::StaticMemberExpression(static_member) => expr_has_top_level_await(&static_member.object),
expr_has_top_level_await(&static_member.object) ChainElement::PrivateFieldExpression(private_field) => expr_has_top_level_await(&private_field.object),
}
ChainElement::PrivateFieldExpression(private_field) => {
expr_has_top_level_await(&private_field.object)
}
} }
} }
crates/oxide_emit/tests/module_link_tests.rs
+13 -44
View File
@@ -478,12 +478,8 @@ fn no_defer_object_for_non_defer_modules() {
/// 无异步依赖时不发聚合 gate。 /// 无异步依赖时不发聚合 gate。
#[test] #[test]
fn tla_module_compiles_async_without_gate() { fn tla_module_compiles_async_without_gate() {
let (ir, _) = emit_module( let (ir, _) = emit_module("const x = await Promise.resolve(1); export { x };", "./entry.js", &[])
"const x = await Promise.resolve(1); export { x };", .expect("TLA 模块应编译成功");
"./entry.js",
&[],
)
.expect("TLA 模块应编译成功");
assert!(ir.is_async, "含顶层 await 的模块应标记异步求值"); assert!(ir.is_async, "含顶层 await 的模块应标记异步求值");
assert_eq!( assert_eq!(
ir.insts.iter().filter(|i| i.op == OpCode::AWAIT).count(), ir.insts.iter().filter(|i| i.op == OpCode::AWAIT).count(),
@@ -497,48 +493,29 @@ fn tla_module_compiles_async_without_gate() {
/// 异步函数体内的 await 不使模块变异步（await 落在嵌套子模块）。 /// 异步函数体内的 await 不使模块变异步（await 落在嵌套子模块）。
#[test] #[test]
fn non_tla_module_stays_sync() { fn non_tla_module_stays_sync() {
let (ir, _) = emit_module( let (ir, _) =
"async function f() { return await Promise.resolve(1); } export { f };", emit_module("async function f() { return await Promise.resolve(1); } export { f };", "./entry.js", &[])
"./entry.js", .expect("非 TLA 模块应编译成功");
&[],
)
.expect("非 TLA 模块应编译成功");
assert!(!ir.is_async, "无顶层 await 的模块不得标记异步"); assert!(!ir.is_async, "无顶层 await 的模块不得标记异步");
assert_eq!( assert_eq!(ir.insts.iter().filter(|i| i.op == OpCode::AWAIT).count(), 0, "主身不得含 AWAIT");
ir.insts.iter().filter(|i| i.op == OpCode::AWAIT).count(),
0,
"主身不得含 AWAIT"
);
} }
/// 面 21：`for await…of` 在模块代码使模块异步（规范强制模块异步求值， /// 面 21：`for await…of` 在模块代码使模块异步（规范强制模块异步求值，
/// `await` 关键字触发 [[HasTLA]]；右值与体照常游走）。 /// `await` 关键字触发 [[HasTLA]]；右值与体照常游走）。
#[test] #[test]
fn for_await_of_makes_module_async() { fn for_await_of_makes_module_async() {
let (ir, _) = emit_module( let (ir, _) = emit_module("for await (const x of iter) { globalThis.v = x; }", "./entry.js", &[])
"for await (const x of iter) { globalThis.v = x; }", .expect("for await…of 模块应编译成功");
"./entry.js",
&[],
)
.expect("for await…of 模块应编译成功");
assert!(ir.is_async, "for await…of 应使模块标记异步"); assert!(ir.is_async, "for await…of 应使模块标记异步");
} }
/// 面 22：普通 `for…of`（无 `await`）不使模块异步，主身零 AWAIT。 /// 面 22：普通 `for…of`（无 `await`）不使模块异步，主身零 AWAIT。
#[test] #[test]
fn for_of_is_not_tla() { fn for_of_is_not_tla() {
let (ir, _) = emit_module( let (ir, _) =
"for (const x of iter) { globalThis.v = x; }", emit_module("for (const x of iter) { globalThis.v = x; }", "./entry.js", &[]).expect("for…of 模块应编译成功");
"./entry.js",
&[],
)
.expect("for…of 模块应编译成功");
assert!(!ir.is_async, "普通 for…of 不得使模块标记异步"); assert!(!ir.is_async, "普通 for…of 不得使模块标记异步");
assert_eq!( assert_eq!(ir.insts.iter().filter(|i| i.op == OpCode::AWAIT).count(), 0, "主身不得含 AWAIT");
ir.insts.iter().filter(|i| i.op == OpCode::AWAIT).count(),
0,
"主身不得含 AWAIT"
);
} }
/// 面 23：异步 eager 依赖聚合 gate——依赖含顶层 `await` 时 `__moduleEval` 返回 /// 面 23：异步 eager 依赖聚合 gate——依赖含顶层 `await` 时 `__moduleEval` 返回
@@ -553,11 +530,7 @@ fn async_dep_emits_wait_all_gate() {
.expect("含异步依赖的模块应编译成功"); .expect("含异步依赖的模块应编译成功");
assert!(ir.is_async, "含异步依赖的导入方应标记异步求值"); assert!(ir.is_async, "含异步依赖的导入方应标记异步求值");
assert_eq!(native_calls_to(&ir, "__moduleWaitAll"), 1, "聚合 gate 应发一次"); assert_eq!(native_calls_to(&ir, "__moduleWaitAll"), 1, "聚合 gate 应发一次");
assert_eq!( assert_eq!(ir.insts.iter().filter(|i| i.op == OpCode::AWAIT).count(), 1, "gate 应以单 AWAIT 挂起");
ir.insts.iter().filter(|i| i.op == OpCode::AWAIT).count(),
1,
"gate 应以单 AWAIT 挂起"
);
} }
/// 面 24：同步依赖零 diff 守卫——无 gate、无 AWAIT、模块保持同步。 /// 面 24：同步依赖零 diff 守卫——无 gate、无 AWAIT、模块保持同步。
@@ -571,9 +544,5 @@ fn sync_dep_no_gate() {
.expect("含同步依赖的模块应编译成功"); .expect("含同步依赖的模块应编译成功");
assert!(!ir.is_async, "无顶层 await 且依赖同步的模块不得标记异步"); assert!(!ir.is_async, "无顶层 await 且依赖同步的模块不得标记异步");
assert_eq!(native_calls_to(&ir, "__moduleWaitAll"), 0, "同步依赖不得发聚合 gate"); assert_eq!(native_calls_to(&ir, "__moduleWaitAll"), 0, "同步依赖不得发聚合 gate");
assert_eq!( assert_eq!(ir.insts.iter().filter(|i| i.op == OpCode::AWAIT).count(), 0, "主身不得含 AWAIT");
ir.insts.iter().filter(|i| i.op == OpCode::AWAIT).count(),
0,
"主身不得含 AWAIT"
);
} }
crates/oxide_vm/src/promise/aggregate.rs
+1 -3
View File
@@ -184,9 +184,7 @@ impl Vm {
promises.push(self.reg(args[i + 1])); promises.push(self.reg(args[i + 1]));
} }
let array = self.make_plain_array(promises); let array = self.make_plain_array(promises);
let ctor = JsValue::from_js_object( let ctor = JsValue::from_js_object(self.realm.promise_constructor.borrow().as_ptr() as *mut JsObject);
self.realm.promise_constructor.borrow().as_ptr() as *mut JsObject,
);
match perform_promise_combine(self, ctor, array, AggregateKind::All) { match perform_promise_combine(self, ctor, array, AggregateKind::All) {
Ok(promise) => NativeResult::Ok(promise), Ok(promise) => NativeResult::Ok(promise),
Err(err) => NativeResult::Err(err), Err(err) => NativeResult::Err(err),