ITStudio_OUC/OxideJS-New
0
1
Fork 0
mirror of https://github.com/pjh456/OxideJS.git synced 2026-10-23 18:21: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::{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),
}
}
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。
#[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");
}
crates/oxide_vm/src/promise/aggregate.rs
+1 -3
View File
@@ -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),