镜像站点 · 本页由第三方 GitHub 只读镜像提供,非 GitHub 官方站点,不接受任何登录或凭据输入。前往 github.com
Skip to content

Commit f2340f2

Browse files
committed
feat(vm): lower canonical parameter expressions (#806)
Remove the duplicate parameter-expression and pattern syntax whitelist. Run canonical expression/pattern lowering under the existing parameter binding phase, retaining ordered initialization, later-formal TDZ, parameter/body scope separation, captured identities and causal parameter-prologue refusal. Propagate allocation failure instead of turning it into fallback admission. Resolve prerequisite aggregate ownership in #808: retain and reload array and object literal results, computed keys, CopyDataProperties source/destination, iterator acquisition/next methods and iteration results through reentrant effects. Native literal helpers return the relocated destination. CopyDataProperties defines own data properties without invoking target setters, rechecks each live source descriptor and never copies an inherited value after deletion. Reuse existing precise temporary-root and object publication mechanisms; native stack/queue/job and activation lifecycle ownership is unchanged. Same 9643 eligible positive upstream Test262 files: required-bytecode passes 8842 -> 9633 (791 gains), failures 801 -> 10, zero regressions. Gains by subtree: expressions/arrow-function 172 -> 250, expressions/class 3165 -> 3443, expressions/function 147 -> 225, expressions/object/method-definition 197 -> 198, statements/class 3424 -> 3702, statements/function 313 -> 391. The other seven required-tier subtrees are unchanged. All 13 default-tier reports remain byte-identical (11494 passes); extra object 1170, array 52, new 59 and optional chain 38 controls are also unchanged. Flips zero default-tier upstream cases in this measured scope; object/method-definition overlaps the extra object run. Retained paired witnesses improve 2/47 -> 47/47, with all expected values independently verified by Node. Debug, ReleaseSafe and unsuppressed TSan pass 47 semantic cases in both tiers, 28 actual-moving cases, four-worker shared no-GIL calls and compiler allocation replay. Existing runtime reentrant OOM restoration also passes in all three modes. Full Debug: 2042 pass, one platform skip, zero failures/leaks, 604.5 seconds across four shards. Seed-one fuzz passes 400 default and 300 exact-verify programs with zero failures. Private constructor grammar is separately landed in #807. Keep #810's deeper Proxy metadata ownership audit separate: these caller roots do not prove its callee-local operands safe. Pushed integration remains independently tracked; no benchmark or universal conformance claim is made.
1 parent d317083 commit f2340f2

4 files changed

Lines changed: 306 additions & 193 deletions

File tree

‎src/compiler.zig‎

Lines changed: 64 additions & 132 deletions
Original file line numberDiff line numberDiff line change
@@ -542,115 +542,6 @@ const PlainParameterLayout = struct {
542542
}
543543
};
544544

545-
fn supportedPlainParameterReference(node: *const ast.Node, fnode: *const ast.FunctionNode) bool {
546-
return switch (node.*) {
547-
.identifier, .member, .super_member => supportedPlainParameterDefault(node, fnode),
548-
else => false,
549-
};
550-
}
551-
552-
fn supportedPlainParameterDefault(node: *const ast.Node, fnode: *const ast.FunctionNode) bool {
553-
// FunctionDeclarationInstantiation installs invocation context first, and
554-
// each prior formal completes BindingInitialization before the next one.
555-
// The recursive cases below use only these exact leaves and canonical VM
556-
// operations; every unlisted AST kind remains a fail-closed barrier.
557-
return switch (node.*) {
558-
.number, .bigint_lit, .string, .boolean, .null_lit, .undefined_lit => true,
559-
.this_expr, .new_target_expr => !fnode.requires_tree_walk_class_constructor,
560-
// FunctionDeclarationInstantiation creates all formal cells before
561-
// initializing them left-to-right. Exceptions from self/later reads
562-
// belong to execution, not admission. The parameter binding phase
563-
// resolves checked formals and exact outer records without exposing
564-
// the body's not-yet-created VariableEnvironment.
565-
.identifier => true,
566-
.unary => |unary| supportedPlainParameterDefault(unary.operand, fnode),
567-
.binary => |binary| supportedPlainParameterDefault(binary.left, fnode) and
568-
supportedPlainParameterDefault(binary.right, fnode),
569-
.logical => |logical| supportedPlainParameterDefault(logical.left, fnode) and
570-
supportedPlainParameterDefault(logical.right, fnode),
571-
.conditional => |conditional| supportedPlainParameterDefault(conditional.cond, fnode) and
572-
supportedPlainParameterDefault(conditional.consequent, fnode) and
573-
supportedPlainParameterDefault(conditional.alternate, fnode),
574-
.sequence => |sequence| supportedPlainParameterDefault(sequence.first, fnode) and
575-
supportedPlainParameterDefault(sequence.second, fnode),
576-
// Assignment/Update Evaluation retains one Reference through GetValue,
577-
// RHS/coercion, and PutValue. Use the ordinary parameter-phase binding
578-
// plans and activation-owned member temporaries; resolving the target
579-
// again after an observable effect would select the wrong binding.
580-
.assign => |assignment| supportedPlainParameterReference(assignment.target, fnode) and
581-
supportedPlainParameterDefault(assignment.value, fnode),
582-
.op_assign => |assignment| supportedPlainParameterReference(assignment.target, fnode) and
583-
supportedPlainParameterDefault(assignment.value, fnode),
584-
.logical_assign => |assignment| supportedPlainParameterReference(assignment.target, fnode) and
585-
supportedPlainParameterDefault(assignment.value, fnode),
586-
.update => |update| supportedPlainParameterReference(update.target, fnode),
587-
// Function/arrow creation itself has no user-code side effect. Its
588-
// nested compiler performs the exact capture/admission checks, while
589-
// eager parameter-environment materialization preserves closure identity.
590-
.function => true,
591-
.member => |member| !member.optional and
592-
(member.computed != null or !value_mod.isRawPrivateName(member.property)) and
593-
supportedPlainParameterDefault(member.object, fnode) and
594-
(member.computed == null or supportedPlainParameterDefault(member.computed.?, fnode)),
595-
.call => |call| blk: {
596-
if (call.optional or !supportedPlainParameterDefault(call.callee, fnode))
597-
break :blk false;
598-
for (call.args) |argument|
599-
if (argument.* == .spread or !supportedPlainParameterDefault(argument, fnode))
600-
break :blk false;
601-
break :blk true;
602-
},
603-
.new_expr => |construction| blk: {
604-
if (!supportedPlainParameterDefault(construction.callee, fnode))
605-
break :blk false;
606-
for (construction.args) |argument|
607-
if (argument.* == .spread or !supportedPlainParameterDefault(argument, fnode))
608-
break :blk false;
609-
break :blk true;
610-
},
611-
.super_member => |member| fnode.is_derived_class_constructor and
612-
(member.computed == null or supportedPlainParameterDefault(member.computed.?, fnode)),
613-
.super_call => |arguments| blk: {
614-
if (!fnode.is_derived_class_constructor) break :blk false;
615-
for (arguments) |argument|
616-
if (argument.* == .spread or !supportedPlainParameterDefault(argument, fnode))
617-
break :blk false;
618-
break :blk true;
619-
},
620-
else => false,
621-
};
622-
}
623-
624-
fn supportedPlainParameterPattern(pattern: *const ast.Node, fnode: *const ast.FunctionNode) bool {
625-
return switch (pattern.*) {
626-
.identifier => true,
627-
.obj_pattern => |object| blk: {
628-
for (object.props) |property| {
629-
if (property.key_expr) |key|
630-
if (!supportedPlainParameterDefault(key, fnode)) break :blk false;
631-
if (property.default) |default|
632-
if (!supportedPlainParameterDefault(default, fnode)) break :blk false;
633-
if (!supportedPlainParameterPattern(property.target, fnode)) break :blk false;
634-
}
635-
if (object.rest) |rest|
636-
if (!supportedPlainParameterPattern(rest, fnode)) break :blk false;
637-
break :blk true;
638-
},
639-
.arr_pattern => |array| blk: {
640-
for (array.elems) |element| {
641-
if (element.default) |default|
642-
if (!supportedPlainParameterDefault(default, fnode)) break :blk false;
643-
if (element.target) |target|
644-
if (!supportedPlainParameterPattern(target, fnode)) break :blk false;
645-
}
646-
if (array.rest) |rest|
647-
if (!supportedPlainParameterPattern(rest, fnode)) break :blk false;
648-
break :blk true;
649-
},
650-
else => false,
651-
};
652-
}
653-
654545
fn configurePlainParameters(
655546
arena: std.mem.Allocator,
656547
scope: *FnScope,
@@ -659,12 +550,8 @@ fn configurePlainParameters(
659550
scope.may_extend_environment = !fnode.is_strict and fnode.uses_direct_eval;
660551
var has_parameter_expressions = false;
661552
for (fnode.params) |parameter| {
662-
if (parameter.default) |default| {
663-
if (!supportedPlainParameterDefault(default, fnode)) return error.Unsupported;
664-
has_parameter_expressions = true;
665-
}
553+
if (parameter.default != null) has_parameter_expressions = true;
666554
if (parameter.pattern) |pattern| {
667-
if (!supportedPlainParameterPattern(pattern, fnode)) return error.Unsupported;
668555
has_parameter_expressions = has_parameter_expressions or patternHasEvaluationExpressions(pattern);
669556
}
670557
}
@@ -2235,7 +2122,14 @@ pub const Compiler = struct {
22352122
.debug_checkpoints = true,
22362123
};
22372124
if (!fnode.is_derived_class_constructor) try c.compileClassInitializers(fnode.class_instance_initializers);
2238-
try c.compilePlainParameterEntries(fnode, &parameter_layout);
2125+
// FunctionDeclarationInstantiation uses the same expression and pattern
2126+
// semantics as body evaluation, under the parameter binding phase. Let
2127+
// canonical lowering decide eligibility, preserving the causal audit
2128+
// reason rather than maintaining a second syntax whitelist.
2129+
c.compilePlainParameterEntries(fnode, &parameter_layout) catch |err| switch (err) {
2130+
error.Unsupported => return rejectPlainFunction(rejection, .parameter_prologue),
2131+
error.OutOfMemory => return error.OutOfMemory,
2132+
};
22392133
try c.emitParameterBodyCopies();
22402134
if (fnode.is_expr_body) {
22412135
try c.compileTailExpr(fnode.body);
@@ -6215,7 +6109,16 @@ pub const Compiler = struct {
62156109
.derived_instance_initializers = if (fnode.is_arrow) self.derived_instance_initializers else &.{},
62166110
.debug_checkpoints = self.debug_checkpoints,
62176111
};
6218-
try sub_c.compilePlainParameterEntries(fnode, &parameter_layout);
6112+
sub_c.compilePlainParameterEntries(fnode, &parameter_layout) catch |err| switch (err) {
6113+
error.Unsupported => {
6114+
if (self.scope == null) {
6115+
template_admission = .plain_parameter_prologue;
6116+
break :blk null;
6117+
}
6118+
return error.Unsupported;
6119+
},
6120+
error.OutOfMemory => return error.OutOfMemory,
6121+
};
62196122
try sub_c.emitParameterBodyCopies();
62206123
if (fnode.is_expr_body) {
62216124
sub_c.compileExpr(fnode.body) catch |e| switch (e) {
@@ -7075,25 +6978,42 @@ test "compiler repeated body query preserves capture classifications" {
70756978
}
70766979
}
70776980

6981+
test "canonical parameter lowering unwinds every compiler allocation failure" {
6982+
const Probe = struct {
6983+
fn run(backing: std.mem.Allocator) !void {
6984+
var arena = std.heap.ArenaAllocator.init(backing);
6985+
defer arena.deinit();
6986+
var parser = try @import("parser.zig").Parser.init(arena.allocator(),
6987+
\\function make(seed, holder={value:seed}, [first,...rest]=[holder,...[]],
6988+
\\ Box=class{field=first;read(){return holder.value;}},
6989+
\\ pattern=/x/g, value=new Box(...[]),
6990+
\\ read=value?.read?.(), changed=({value:seed}=holder)) {
6991+
\\ return [value,pattern,read,changed];
6992+
\\}
6993+
);
6994+
const program = try parser.parseProgram();
6995+
const compiled = switch (try Compiler.admitPlainFunction(arena.allocator(), program.program[0].func_decl)) {
6996+
.compiled => |compiled| compiled,
6997+
.rejected => return error.TestUnexpectedResult,
6998+
};
6999+
try std.testing.expectEqual(@as(usize, 7), compiled.chunk.default_parameter_indices.len);
7000+
try std.testing.expectEqual(@as(usize, 1), compiled.chunk.destructuring_parameter_indices.len);
7001+
try std.testing.expectEqual(@as(usize, 1), compiled.chunk.classes.items.len);
7002+
try std.testing.expect(compiled.chunk.classes.items[0].capture_environment != null);
7003+
try std.testing.expect(compiled.chunk.has_non_simple_parameters);
7004+
}
7005+
};
7006+
try std.testing.checkAllAllocationFailures(std.testing.allocator, Probe.run, .{});
7007+
}
7008+
70787009
test "compiler reports stable plain-function admission reasons" {
70797010
const cases = [_]struct {
70807011
source: []const u8,
70817012
expected: Compiler.PlainFunctionRejection,
70827013
}{
70837014
.{ .source = "function* f(){}", .expected = .generator_or_async },
70847015
.{ .source = "function f(){ using resource = source; }", .expected = .function_scope_disposal },
7085-
.{ .source = "function f(first, value = first?.value){}", .expected = .parameter_prologue },
7086-
.{ .source = "function f(first, value = first?.()){}", .expected = .parameter_prologue },
7087-
.{ .source = "function f(first, args, value = first(...args)){}", .expected = .parameter_prologue },
7088-
.{ .source = "function f(first, args, value = new first(...args)){}", .expected = .parameter_prologue },
7089-
.{ .source = "function f(value = /x/){}", .expected = .parameter_prologue },
7090-
.{ .source = "function f(value = {}){}", .expected = .parameter_prologue },
7091-
.{ .source = "function f(value = []){}", .expected = .parameter_prologue },
7092-
.{ .source = "function f(value = class {}){}", .expected = .parameter_prologue },
7093-
.{ .source = "function f(value = (holder.value = {})){}", .expected = .parameter_prologue },
7094-
.{ .source = "function f(value = (outer += side?.())){}", .expected = .parameter_prologue },
7095-
.{ .source = "function f(value = delete holder.value){}", .expected = .parameter_prologue },
7096-
.{ .source = "function f([value] = []){}", .expected = .parameter_prologue },
7016+
.{ .source = "function f(value = function(){ using resource = source; }){}", .expected = .parameter_prologue },
70977017
};
70987018

70997019
for (cases) |case| {
@@ -7109,6 +7029,18 @@ test "compiler reports stable plain-function admission reasons" {
71097029
}
71107030

71117031
const admitted_parameter_prologues = [_][]const u8{
7032+
"function f(first, value = first?.value){}",
7033+
"function f(first, value = first?.()){}",
7034+
"function f(first, args, value = first(...args)){}",
7035+
"function f(first, args, value = new first(...args)){}",
7036+
"function f(value = /x/){}",
7037+
"function f(value = {}){}",
7038+
"function f(value = []){}",
7039+
"function f(value = class {}){}",
7040+
"function f(value = (holder.value = {})){}",
7041+
"function f(value = (outer += side?.())){}",
7042+
"function f(value = delete holder.value){}",
7043+
"function f([value] = []){}",
71127044
"function f(value = ++outer){}",
71137045
"function f(value = outer--){}",
71147046
"function f(value = outer += 2){}",
@@ -7222,8 +7154,8 @@ test "compiler reports stable plain-function admission reasons" {
72227154
return error.TestUnexpectedResult;
72237155
const super_method = super_class.class_expr.members[0].func orelse return error.TestUnexpectedResult;
72247156
switch (try Compiler.admitPlainFunction(super_arena.allocator(), super_method.function)) {
7225-
.compiled => return error.TestUnexpectedResult,
7226-
.rejected => |reason| try std.testing.expectEqual(.parameter_prologue, reason),
7157+
.compiled => {},
7158+
.rejected => return error.TestUnexpectedResult,
72277159
}
72287160

72297161
var private_new_arena = std.heap.ArenaAllocator.init(std.testing.allocator);
@@ -7260,8 +7192,8 @@ test "compiler reports stable plain-function admission reasons" {
72607192
return error.TestUnexpectedResult;
72617193
const super_new_method = super_new_class.class_expr.members[0].func orelse return error.TestUnexpectedResult;
72627194
switch (try Compiler.admitPlainFunction(super_new_arena.allocator(), super_new_method.function)) {
7263-
.compiled => return error.TestUnexpectedResult,
7264-
.rejected => |reason| try std.testing.expectEqual(.parameter_prologue, reason),
7195+
.compiled => {},
7196+
.rejected => return error.TestUnexpectedResult,
72657197
}
72667198

72677199
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);

0 commit comments

Comments
 (0)