@@ -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-
654545fn 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+
70787009test "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