v2: flat-AST migration phase 5

Author: medvednikov

vlib/v2/ast/ast.v

@@ -977,19 +977,25 @@ pub:
 // Type Nodes
 pub struct ArrayType {
 pub:
-	elem_type Expr
+	elem_type Expr = empty_expr
 }
 
 pub struct ArrayFixedType {
 pub:
-	len       Expr
-	elem_type Expr
+	len       Expr = empty_expr
+	elem_type Expr = empty_expr
 }
 
 pub struct ChannelType {
 pub:
-	cap       Expr
-	elem_type Expr
+	// s255: cap defaults to empty_expr (like ThreadType/OptionType/etc.). The
+	// parser omits cap for a bare `chan T` (type.v: `ChannelType{elem_type: ...}`),
+	// which previously left it a zero-valued Expr (invalid sum-type tag, null
+	// payload). Encoding that via FlatBuilder.add_expr crashes the arm64 self-host
+	// — an exhaustive match on the unmatched tag falls into the first arm
+	// (ArrayInitExpr) and derefs the null payload (same class as s251).
+	cap       Expr = empty_expr
+	elem_type Expr = empty_expr
 }
 
 pub struct ThreadType {
@@ -1050,14 +1056,14 @@ pub:
 
 pub struct GenericType {
 pub:
-	name   Expr
+	name   Expr = empty_expr
 	params []Expr
 }
 
 pub struct MapType {
 pub:
-	key_type   Expr
-	value_type Expr
+	key_type   Expr = empty_expr
+	value_type Expr = empty_expr
 }
 
 pub struct NilType {}

vlib/v2/ast/flat.v

@@ -1714,7 +1714,20 @@ fn (mut b FlatBuilder) add_stmt(stmt Stmt) FlatNodeId {
 				flags |= flag_is_static
 			}
 			mut edges := []FlatEdge{}
-			b.push_edge(mut edges, b.add_parameter(stmt.receiver))
+			if stmt.is_method {
+				b.push_edge(mut edges, b.add_parameter(stmt.receiver))
+			} else {
+				// s251: a non-method FnDecl keeps the parser's zero `ast.Parameter{}`
+				// receiver, whose `typ` is a zero-valued Expr (invalid sum-type tag,
+				// null payload). Routing that through add_expr is unsafe on the arm64
+				// self-host: an exhaustive match on an unmatched tag falls into the
+				// first arm (ArrayInitExpr) and derefs the null payload. The receiver
+				// edge is only read for methods, so emit a clean empty receiver
+				// (typ = empty_expr, a valid EmptyExpr) for non-methods.
+				b.push_edge(mut edges, b.add_parameter(Parameter{
+					typ: empty_expr
+				}))
+			}
 			b.push_edge(mut edges, b.add_type(Type(stmt.typ)))
 			b.push_edge(mut edges, b.make_list_attribute(stmt.attributes))
 			b.push_edge(mut edges, b.make_list_stmt(stmt.stmts))

vlib/v2/ast/flat_reader.v

@@ -185,8 +185,7 @@ pub fn (flat &FlatAst) decode_fn_decl_signature(id FlatNodeId) FnDecl {
 	recv_id := r.edge(n, 0)
 	typ_id := r.edge(n, 1)
 	attrs_id := r.edge(n, 2)
-	typ_node := r.read_type(typ_id)
-	fn_typ := if typ_node is FnType { typ_node } else { FnType{} }
+	fn_typ := r.read_fn_type(typ_id)
 	return FnDecl{
 		attributes: r.read_attr_list(attrs_id)
 		is_public:  (n.flags & flag_is_public) != 0
@@ -365,6 +364,77 @@ fn (r &FlatReader) read_parameter_list(id FlatNodeId) []Parameter {
 	return out
 }
 
+// read_fn_type (s252) decodes a `.typ_fn` node straight into a FnType, without
+// the read_type→`Type(FnType{...})`→`is FnType` round-trip. Boxing a large
+// struct into the Type sum type and then unboxing it via smartcast corrupts the
+// FnType's slice headers (generic_params/params) on the arm64 self-host (the
+// documented chained-access/smartcast bug). This path is only ever exercised by
+// the flat decode, so the default self-host never hit it. Edge layout matches
+// the encoder's FnType arm and read_type's `.typ_fn`: 0=generics, 1=params,
+// 2=return_type.
+fn (r &FlatReader) read_fn_type(id FlatNodeId) FnType {
+	if id < 0 {
+		return FnType{}
+	}
+	n := r.node(id)
+	if n.kind != .typ_fn {
+		return FnType{}
+	}
+	return FnType{
+		generic_params: r.read_expr_list(r.edge(n, 0))
+		params:         r.read_parameter_list(r.edge(n, 1))
+		return_type:    r.read_expr(r.edge(n, 2))
+	}
+}
+
+// read_ident (s254) decodes an expr_ident node straight into an Ident, avoiding
+// the read_expr→Expr→`is Ident` smartcast-unbox. Copying a struct out of the Expr
+// sum type via smartcast corrupts its fields (here the `name` string header) on
+// the arm64 self-host (same chained-access/smartcast bug as the FnType unbox in
+// s252). Returns an empty Ident for ids that don't point at an expr_ident.
+fn (r &FlatReader) read_ident(id FlatNodeId) Ident {
+	if id < 0 || id >= r.flat.nodes.len {
+		return Ident{}
+	}
+	n := r.node(id)
+	if n.kind != .expr_ident {
+		return Ident{}
+	}
+	return Ident{
+		pos:  n.pos
+		name: r.get_str(n.name_id)
+	}
+}
+
+// read_assign_stmt (s254) decodes a stmt_assign node straight into an AssignStmt,
+// avoiding the read_stmt→Stmt→`is AssignStmt` unbox (which corrupts the lhs/rhs
+// slice headers on arm64). Mirrors the `.stmt_assign` arm of read_stmt. Returns
+// an empty AssignStmt for ids that don't point at a stmt_assign.
+fn (r &FlatReader) read_assign_stmt(id FlatNodeId) AssignStmt {
+	if id < 0 || id >= r.flat.nodes.len {
+		return AssignStmt{}
+	}
+	n := r.node(id)
+	if n.kind != .stmt_assign {
+		return AssignStmt{}
+	}
+	lhs_len := n.extra
+	mut lhs := []Expr{cap: lhs_len}
+	for i in 0 .. lhs_len {
+		lhs << r.read_expr(r.edge(n, i))
+	}
+	mut rhs := []Expr{cap: n.edge_count - lhs_len}
+	for i in lhs_len .. n.edge_count {
+		rhs << r.read_expr(r.edge(n, i))
+	}
+	return AssignStmt{
+		op:  unsafe { token.Token(int(n.aux)) }
+		lhs: lhs
+		rhs: rhs
+		pos: n.pos
+	}
+}
+
 fn (r &FlatReader) read_string_list(id FlatNodeId) []string {
 	if id < 0 {
 		return []string{}
@@ -499,8 +569,7 @@ fn (r &FlatReader) read_stmt(id FlatNodeId) Stmt {
 			typ_id := r.edge(n, 1)
 			attrs_id := r.edge(n, 2)
 			stmts_id := r.edge(n, 3)
-			typ_node := r.read_type(typ_id)
-			fn_typ := if typ_node is FnType { typ_node } else { FnType{} }
+			fn_typ := r.read_fn_type(typ_id)
 			return Stmt(FnDecl{
 				attributes: r.read_attr_list(attrs_id)
 				is_public:  (n.flags & flag_is_public) != 0
@@ -737,8 +806,7 @@ fn (r &FlatReader) read_expr(id FlatNodeId) Expr {
 		}
 		.expr_fn_literal {
 			fn_typ_id := r.edge(n, 0)
-			typ_node := r.read_type(fn_typ_id)
-			fn_typ := if typ_node is FnType { typ_node } else { FnType{} }
+			fn_typ := r.read_fn_type(fn_typ_id)
 			cap_len := n.extra
 			mut captured := []Expr{cap: cap_len}
 			for i in 0 .. cap_len {
@@ -795,10 +863,11 @@ fn (r &FlatReader) read_expr(id FlatNodeId) Expr {
 			})
 		}
 		.expr_if_guard {
-			child := r.read_stmt(r.edge(n, 0))
-			assign := if child is AssignStmt { child } else { AssignStmt{} }
+			// s254: read the assign straight into an AssignStmt; the old
+			// `read_stmt → if child is AssignStmt { child }` unbox corrupted its
+			// lhs/rhs slice headers on arm64.
 			return Expr(IfGuardExpr{
-				stmt: assign
+				stmt: r.read_assign_stmt(r.edge(n, 0))
 				pos:  n.pos
 			})
 		}
@@ -850,9 +919,12 @@ fn (r &FlatReader) read_expr(id FlatNodeId) Expr {
 			expr := r.read_expr(r.edge(n, 0))
 			mut args := []Ident{cap: n.edge_count - 1}
 			for i in 1 .. n.edge_count {
-				e := r.read_expr(r.edge(n, i))
-				if e is Ident {
-					args << e
+				// s254: read each arg straight into an Ident (the old
+				// `read_expr → if e is Ident { args << e }` unbox corrupted the
+				// Ident's `name` on arm64).
+				arg_id := r.edge(n, i)
+				if arg_id >= 0 && arg_id < r.flat.nodes.len && r.node(arg_id).kind == .expr_ident {
+					args << r.read_ident(arg_id)
 				}
 			}
 			return Expr(LambdaExpr{
@@ -982,12 +1054,13 @@ fn (r &FlatReader) read_expr(id FlatNodeId) Expr {
 			})
 		}
 		.expr_selector {
-			lhs := r.read_expr(r.edge(n, 0))
-			rhs := r.read_expr(r.edge(n, 1))
-			ident := if rhs is Ident { rhs } else { Ident{} }
+			// s254: read the rhs straight into an Ident; the previous
+			// `read_expr → if rhs is Ident { rhs }` unbox corrupted the Ident's
+			// `name` on the arm64 self-host, yielding garbage `missing X.<name>`
+			// checker errors for selector types like `strings.Builder`.
 			return Expr(SelectorExpr{
-				lhs: lhs
-				rhs: ident
+				lhs: r.read_expr(r.edge(n, 0))
+				rhs: r.read_ident(r.edge(n, 1))
 				pos: n.pos
 			})
 		}

vlib/v2/builder/builder.v

@@ -49,6 +49,7 @@ mut:
 	flat_roundtrip_enabled    bool // V2_FLAT_ROUNDTRIP=1: route parses through streaming + to_files()
 	flat_check_enabled        bool // V2_CHECK_FLAT=1: route type-check through Checker.check_flat
 	markused_flat_enabled     bool // V2_MARKUSED_FLAT=1: route markused through mark_used_flat shim
+	flat_ssa_enabled          bool // V2_FLAT_SSA=1: route the (sequential) native SSA build through build_all_from_flat on the post-transform b.flat. Requires V2_CHECK_FLAT + V2_MARKUSED_FLAT so b.flat is post-transform-populated. Default off.
 	// flat caches the FlatAst representation of b.files. When
 	// flat_check_enabled is set, parse_batch streams directly into
 	// flat_builder so b.flat is built incrementally during parsing rather
@@ -73,6 +74,7 @@ pub fn new_builder(prefs &pref.Preferences) &Builder {
 			flat_roundtrip_enabled: os.getenv('V2_FLAT_ROUNDTRIP') != ''
 			flat_check_enabled:     os.getenv('V2_CHECK_FLAT') != ''
 			markused_flat_enabled:  os.getenv('V2_MARKUSED_FLAT') != ''
+			flat_ssa_enabled:       os.getenv('V2_FLAT_SSA') != ''
 		}
 	}
 }
@@ -329,10 +331,14 @@ pub fn (mut b Builder) build(files []string) {
 		}
 		mark_used_time := time.Duration(sw.elapsed() - mark_used_start)
 		print_time('Mark Used', mark_used_time)
-		// b.flat is unused by the codegen path; drop the arenas so a GC build
-		// can reclaim them. Under -gc none this is a no-op for peak memory,
+		// b.flat is unused by the legacy codegen path; drop the arenas so a GC
+		// build can reclaim them. Under -gc none this is a no-op for peak memory,
 		// but it documents the lifetime correctly for the eventual GC switch.
-		b.flat = ast.FlatAst{}
+		// When V2_FLAT_SSA is on, the native SSA build consumes b.flat directly
+		// (build_all_from_flat), so keep it alive through codegen.
+		if !b.flat_ssa_enabled {
+			b.flat = ast.FlatAst{}
+		}
 		print_rss('after markused')
 		print_heap('after markused')
 	}
@@ -2496,7 +2502,20 @@ fn (mut b Builder) build_native_mir_from_files(files []ast.File, arch pref.Arch,
 	}
 
 	mut stage_start := native_sw.elapsed()
-	if b.native_mir_build_sequential(label) {
+	// V2_FLAT_SSA: route the whole SSA build through the cursor-native
+	// build_all_from_flat on the post-transform b.flat (kept alive above).
+	// Sequential only (build_all_from_flat builds fn bodies in-phase). Default off.
+	//
+	// b.flat is only POST-TRANSFORM when V2_MARKUSED_FLAT is also on: that path
+	// routes transform through transform_files_to_flat, which re-flattens the
+	// transformed files back into b.flat. With V2_CHECK_FLAT but NOT
+	// V2_MARKUSED_FLAT, b.flat stays the parse-time (pre-transform) flat while the
+	// transformer only updates b.files, so feeding it to build_all_from_flat would
+	// skip every transformer rewrite. Require both flags here; otherwise fall back
+	// to the legacy build_all(files), which uses the post-transform b.files.
+	if b.flat_ssa_enabled && b.markused_flat_enabled && b.flat_check_enabled && b.flat.files.len > 0 {
+		ssa_builder.build_all_from_flat(&b.flat)
+	} else if b.native_mir_build_sequential(label) {
 		ssa_builder.build_all(files)
 	} else {
 		// Phases 1-3 sequential, Phase 4 parallel, Phase 5 sequential