v3.transform

fn erase_generic_templates(mut a flat.FlatAst, tc &types.TypeChecker, used_fns map[string]bool) map[string]bool

fn monomorphize_with_used(mut a flat.FlatAst, tc &types.TypeChecker, used_fns map[string]bool) map[string]bool

fn monomorphize_with_used_checked(mut a flat.FlatAst, tc &types.TypeChecker, used_fns map[string]bool) (map[string]bool, []string)

monomorphize_with_used_checked also reports semantic errors that can only be resolved after generic parameters have concrete types.

fn reserve_parallel_transform_ast(mut a flat.FlatAst, skip_generics bool)

reserve_parallel_transform_ast reserves persistent append regions before a disposable transform arena is entered.

fn sum_eq_helper_name(sum_name string) string

sum_eq_helper_name is the global C-level name of the synthesized deep-equality helper for a sum type.

fn transform(mut a flat.FlatAst, tc &types.TypeChecker)

transform supports transform handling for transform.

fn transform_with_used(mut a flat.FlatAst, tc &types.TypeChecker, used_fns map[string]bool) map[string]bool

transform_with_used transforms transform with used data for transform.

fn transform_with_used_opt(mut a flat.FlatAst, tc &types.TypeChecker, used_fns map[string]bool, want_parallel bool) (map[string]bool, bool)

transform_with_used_opt is transform_with_used with an opt-in for parallel function-body transform. It returns the augmented used-fn set and whether the function bodies were actually transformed across threads (false when parallel was not requested, the build lacks thread support, or there was too little work).

fn transform_with_used_opt_config(mut a flat.FlatAst, tc &types.TypeChecker, used_fns map[string]bool, want_parallel bool, skip_generics bool) (map[string]bool, bool)

transform_with_used_opt_config is transform_with_used_opt with extra pipeline switches for self-host builds.

fn transform_with_used_opt_config_scoped_workers(mut a flat.FlatAst, tc &types.TypeChecker, used_fns map[string]bool, want_parallel bool, skip_generics bool, scope_parallel_workers bool) (map[string]bool, bool)

transform_with_used_opt_config_scoped_workers optionally gives parallel helpers disposable prealloc arenas. It is used by prealloc self-host builds to retain parallel latency without retaining every helper's scratch memory.

fn transform_with_used_opt_config_scoped_workers_checked(mut a flat.FlatAst, tc &types.TypeChecker, used_fns map[string]bool, want_parallel bool, skip_generics bool, scope_parallel_workers bool) (map[string]bool, bool, []string)

transform_with_used_opt_config_scoped_workers_checked also returns diagnostics selected while normal comptime reflection loops are unrolled.

fn transform_with_used_opt_config_scoped_workers_checked_owned(mut a flat.FlatAst, tc &types.TypeChecker, used_fns map[string]bool, want_parallel bool, skip_generics bool, scope_parallel_workers bool, stage_scope voidptr) (map[string]bool, bool, []string, []int, []ScopedTransformRegion)

transform_with_used_opt_config_scoped_workers_checked_owned additionally reports source AST nodes whose owned payloads were replaced during a scoped transform, so the driver can promote exactly those escaping values.

fn SqlDynamicDataKind.from[W](input W) !SqlDynamicDataKind

fn SqlTransformStmtKind.from[W](input W) !SqlTransformStmtKind

struct FieldInfo {
pub:
	name         string
	typ          string
	raw_typ      string
	default_expr flat.NodeId
	is_embedded  bool
}

FieldInfo stores field info metadata used by transform.

struct ScopedTransformRegion {
pub:
	scope      voidptr
	new_start  int
	new_end    int
	base_nodes []int
}

ScopedTransformRegion describes AST payloads owned by one retained worker arena. The driver canonicalizes this region before releasing the arena.

struct SmartcastContext {
pub:
	expr_name     string // the expression being smartcast (e.g. "node")
	variant_name  string // the variant type name (e.g. "Ident")
	sum_type_name string // the parent sum type name (e.g. "Expr")
}

SmartcastContext stores smartcast context state used by transform.

struct StructInfo {
pub:
	name       string
	module     string
	is_params  bool
	is_aligned bool
	alignment  string
	fields     []FieldInfo
}

StructInfo stores struct info metadata used by transform.

struct SumEqRequest {
pub:
	module        string
	file          string
	helper_module string
}

SumEqRequest records where a sum type's equality helper was first requested, so the helper body is built under that module/file resolution context. The helper module can differ for program-specific generic specializations, whose generated functions and helpers must stay in the main cache segment.

struct Transformer {
mut:
	a                             &flat.FlatAst      = unsafe { nil }
	tc                            &types.TypeChecker = unsafe { nil }
	structs                       map[string]StructInfo
	struct_short_name_index       map[string]string
	struct_short_name_index_ready bool
	unique_fields                 map[string]string
	alias_methods                 map[string]string
	globals                       map[string]string
	sum_types                     map[string][]string
	sum_variant_parents           map[string][]string
	sum_variant_names             map[string]bool
	sum_variant_fields            map[string]string
	qualified_types               map[string]string
	fn_ret_types                  map[string]string
	multi_return_fn_ret_types     map[string]types.Type
	receiver_method_suffix_index  map[string]string
	variadic_suffix_index         map[string]i8
	const_suffixes                map[string]string
	enum_types                    map[string][]string
	enum_backing_types            map[string]string
	cur_file                      string
	cur_module                    string
	cur_fn_name                   string
	cur_fn_ret_type               string
	cur_fn_is_generic             bool
	skip_generics                 bool
	var_types                     []VarTypeBinding
	var_type_indices              map[string]int
	refined_node_types            map[int]string
	fn_value_locals               map[string]string
	mut_param_values              map[string]bool
	fixed_array_param_values      map[string]bool
	mut_value_ident_nodes         map[int]bool
	pointer_value_lvalues         map[string]bool
	pointer_value_rvalues         map[string]bool
	addr_lvalue_pointer_locals    map[string]bool
	orm_initialized_fields        map[string][]string
	sql_query_data_aliases        map[string][]string
	bound_method_arrays           map[string]BoundMethodArrayInfo
	temp_counter                  int
	global_temp_counter           int
	pending_stmts                 []flat.NodeId
	smartcast_stack               []SmartcastContext
	invalidated_smartcasts        map[string]bool
	in_call_callee                bool
	in_monomorphize_scan          bool
	validating_generic_spec       bool
	monomorph_errors              []string
	monomorph_error_seen          map[string]bool
	in_spawn_expr                 bool
	has_spawn_expr                bool
	in_const_init                 bool
	in_return_expr                bool
	in_string_interp_part         bool
	expected_expr_node            int = -1
	expected_expr_type            string
	in_selector_base              bool
	autolock_depth                int
	alias_cache                   &AliasCache             = unsafe { nil }
	sum_cache                     &AliasCache             = unsafe { nil }
	generic_unresolved_cache      &GenericUnresolvedCache = unsafe { nil }
	struct_field_type_cache       &LookupCache            = unsafe { nil }
	variant_short_name_cache      &LookupCache            = unsafe { nil }
	interface_box_param_cache     &BoolLookupCache        = unsafe { nil }
	alias_receiver_method_cache   &LookupCache            = unsafe { nil }
	call_variadic_cache           &BoolLookupCache        = unsafe { nil }
	str_alias_cache               &LookupCache            = unsafe { nil }
	call_param_types_decl_cache   map[string][]types.Type
	call_param_types_decl_misses  map[string]bool
	call_param_types_decl_index   map[string]FnParamDeclRef
	call_param_types_index_ready  bool
	used_fns                      map[string]bool
	used_fns_parent               &map[string]bool = unsafe { nil }
	used_fns_root                 &map[string]bool = unsafe { nil }
	comptime_reflected_params     map[string][]ParamMeta
	// sum_eq_types records sum types whose deep-equality helper fn
	// (__v3_sum_eq_<name>) is called somewhere, keyed by sum name with the
	// module/file context of the requesting call site (type resolution inside
	// the helper body needs that context). The helpers are synthesized
	// serially after the (possibly parallel) transform completes.
	sum_eq_types                 map[string]SumEqRequest
	sum_eq_synthesized           map[string]bool
	sum_eq_helper_module         string
	interface_boxed_types        map[string]bool
	interface_boxed_types_done   bool
	interface_boxed_types_frozen bool
	ierror_none_type_id          int
	interface_var_concrete_types map[string]string
	// used_struct_operator_fns holds the callee names of direct calls seen during
	// monomorphize. Infix operators on generic instances are lowered to direct calls
	// (`Vec_int__plus(a, b)`) before this pass, so an operator overload is specialized for
	// an instantiated generic struct only when its mangled name appears here — an instance
	// whose type argument never has the operator applied is not emitted with a body that
	// would fail C compilation.
	used_struct_operator_fns map[string]bool
	// active_generic_params holds the generic parameter names of the decl currently
	// being specialized/rewritten, in the same order as the inferred type `args`.
	// It lets type-text substitution map placeholders by name (so non-canonical
	// params like `D`/`F` resolve to the right arg) instead of by the positional
	// `generic_param_index` heuristic (which collapses anything outside the T/U/C
	// sequences to index 0). Empty for struct-generic specialization, which keeps
	// the legacy positional behaviour.
	active_generic_params []string
	// cloning_comptime_for_depth > 0 while a generic clone descends into a `$for` body: nested
	// generic calls there must not be specialized (the loop var members are not resolved yet).
	cloning_comptime_for_depth int
	cloning_comptime_for_vars  []string
	// ignored_comptime_for_nodes marks source `$for` subtrees replaced by concrete
	// unrolled nodes. Keeping the marker outside the shared flat AST lets parallel
	// workers record their own discarded nodes without racing.
	ignored_comptime_for_nodes  []bool
	ignored_comptime_for_log    []int
	ignored_comptime_log_active bool
	// cloning_generic_fn_depth > 0 while a generic specialization is cloned with a live,
	// seeded parameter scope. Ident inference should use that scope rather than scan annotations.
	cloning_generic_fn_depth int
	// escaping_amp_ptrs holds the names of pointer locals `p` declared as `p := &v`
	// (v a value local) whose pointer escapes the function (is returned). V semantics
	// auto-heap such a `v`; v3 otherwise takes the address of a stack local that dies
	// on return. Recomputed per function (structural pre-pass in transform_fn_body),
	// consumed when the `p := &v` decl is transformed (RHS rewritten to a heap copy).
	escaping_amp_ptrs map[string]bool
	// escaping_amp_sources holds the source locals `v` of such `p := &v` escapes. A returned
	// pointer local can collect more than one source through later assignments (`p = &w`);
	// each possible source whose address may leave the frame is moved to the heap at its
	// declaration so mutations before the return remain visible to the caller.
	escaping_amp_sources map[string]bool
	// heaped_amp_locals records which of those sources were actually moved to the heap, so
	// the `p := &v` alias emits `p = v` (the heap pointer) instead of a fresh memdup copy.
	heaped_amp_locals map[string]bool
	// escaping_interface_box_locals holds interface locals boxed from stack-backed pointer
	// sources and later returned. The box can alias the stack value while in scope, but its
	// `_object` needs a heap copy before the interface value leaves the frame.
	escaping_interface_box_locals    map[string]bool
	generic_specialization_args      map[string][]string
	generic_fn_specs_in_progress     map[string]bool
	generic_fn_decls_cache           map[string]GenericFnDecl
	generic_receiver_methods_by_name map[string][]string
	generic_fn_decls_ready           bool
	generic_call_spec_cache          map[int]GenericCallSpec
	generic_call_spec_misses         map[int]bool
	stringify_stack                  []string
	node_module_map_cache            []string
	node_file_map_cache              []string
	node_module_map_nodes            int = -1
	// used_fns_log records names newly inserted into used_fns while the
	// late-used-fn-bodies pass runs, so that pass can tell "was this name
	// already used before the current body's transform" without cloning the
	// whole used_fns map per function (those clones dominated the pass's time
	// and, under -gc none, were never freed).
	used_fns_log        []string
	used_fns_log_active bool
	// transformed_fns[i] is set when the fn_decl at node id i has had its body
	// transformed (main pass, any thread — worker chunks are marked at merge).
	// The late-used-fn-bodies pass excludes these candidates: lowered bodies
	// surface sanitized call spellings (`seed__time_seed_array`) that the
	// used-set (holding `seed.time_seed_array`) cannot filter, which used to
	// re-transform hundreds of already-transformed bodies every build.
	transformed_fns []bool
	// Shared-base (clone-free) parallel transform: all threads operate on views
	// of the master arrays, appending into pre-partitioned capacity regions.
	// While base_write_intercept is set, in-place writes to base-range node
	// slots outside the current item's subtree range [item_range_lo,
	// item_range_hi] are dropped (workers — matching the old clone path, where
	// such writes stayed in the discarded clone) or deferred until after join
	// (master, defer_oor_writes — matching the old path where the master's
	// writes landed on the shared AST).
	base_write_intercept bool
	defer_oor_writes     bool
	shared_base_nodes    int = -1
	item_range_lo        int = -1
	item_range_hi        int = -1
	deferred_base_writes []DeferredBaseWrite
	// Prealloc self-host builds put helper-thread scratch allocations in
	// disposable arenas. The worker's surviving AST strings are cloned by the
	// master before that arena is released.
	scope_parallel_workers  bool
	worker_scope            voidptr
	scoped_base_nodes       int = -1
	scoped_owned_base_nodes map[int]bool
	scoped_owned_base_log   []int
	scoped_base_log_active  bool
	scoped_promoted_texts   map[string]string
	retain_worker_results   bool
	retained_worker_regions []ScopedTransformRegion
	stage_scope             voidptr
}

Transformer represents transformer data used by transform.

fn (mut t Transformer) drain_pending(mut result []flat.NodeId)

drain_pending supports drain pending handling for Transformer.

fn (t &Transformer) find_smartcast(expr_name string) ?SmartcastContext

find_smartcast resolves find smartcast information for transform.

fn (t &Transformer) get_global_type(name string) ?string

get_global_type returns get global type data for Transformer.

fn (t &Transformer) get_struct_info(name string) ?StructInfo

get_struct_info returns get struct info data for Transformer.

fn (t &Transformer) is_sum_variant(name string) bool

is_sum_variant reports whether is sum variant applies in transform.

fn (mut t Transformer) make_array_init(elem_type string) flat.NodeId

make_array_init builds make array init data for transform.

fn (mut t Transformer) make_assign(lhs flat.NodeId, rhs flat.NodeId) flat.NodeId

make_assign builds make assign data for transform.

fn (mut t Transformer) make_assign_op(lhs flat.NodeId, rhs flat.NodeId, op flat.Op) flat.NodeId

make_assign_op builds make assign op data for transform.

fn (mut t Transformer) make_block(stmts []flat.NodeId) flat.NodeId

make_block builds make block data for transform.

fn (mut t Transformer) make_bool_literal(value bool) flat.NodeId

make_bool_literal builds make bool literal data for transform.

fn (mut t Transformer) make_call(fn_name string, args []flat.NodeId) flat.NodeId

make_call builds make call data for transform.

fn (mut t Transformer) make_call_expr_typed(fn_expr flat.NodeId, args []flat.NodeId, typ string) flat.NodeId

make_call_expr_typed builds make call expr typed data for transform.

fn (mut t Transformer) make_call_typed(fn_name string, args []flat.NodeId, typ string) flat.NodeId

make_call_typed builds make call typed data for transform.

fn (mut t Transformer) make_cast(target_type string, expr flat.NodeId, typ string) flat.NodeId

make_cast builds make cast data for transform.

fn (mut t Transformer) make_decl_assign(name string, rhs flat.NodeId) flat.NodeId

make_decl_assign builds make decl assign data for transform.

fn (mut t Transformer) make_empty() flat.NodeId

make_empty builds make empty data for transform.

fn (mut t Transformer) make_expr_stmt(expr flat.NodeId) flat.NodeId

make_expr_stmt builds make expr stmt data for transform.

fn (mut t Transformer) make_float_literal(value string) flat.NodeId

make_float_literal builds make float literal data for transform.

fn (mut t Transformer) make_float_literal_typed(value string, typ string) flat.NodeId

fn (mut t Transformer) make_ident(name string) flat.NodeId

make_ident builds make ident data for transform.

fn (mut t Transformer) make_if(cond flat.NodeId, then_block flat.NodeId, else_block flat.NodeId) flat.NodeId

make_if builds make if data for transform.

fn (mut t Transformer) make_if_with_skip_ownership_drops(cond flat.NodeId, then_block flat.NodeId, else_block flat.NodeId) flat.NodeId

make_if_with_skip_ownership_drops builds a synthetic if that must not consume ownership-drop metadata recorded for source control-flow nodes.

fn (mut t Transformer) make_index(base flat.NodeId, index flat.NodeId, typ string) flat.NodeId

make_index builds make index data for transform.

fn (mut t Transformer) make_infix(op flat.Op, lhs flat.NodeId, rhs flat.NodeId) flat.NodeId

make_infix builds make infix data for transform.

fn (mut t Transformer) make_int_literal(value int) flat.NodeId

make_int_literal builds make int literal data for transform.

fn (mut t Transformer) make_int_literal_typed(value string, typ string) flat.NodeId

fn (mut t Transformer) make_map_init(map_type string) flat.NodeId

make_map_init builds make map init data for transform.

fn (mut t Transformer) make_method_call(receiver flat.NodeId, method_name string, args []flat.NodeId) flat.NodeId

make_method_call builds make method call data for transform.

fn (mut t Transformer) make_paren(expr flat.NodeId) flat.NodeId

make_paren builds make paren data for transform.

fn (mut t Transformer) make_postfix(expr flat.NodeId, op flat.Op) flat.NodeId

make_postfix builds make postfix data for transform.

fn (mut t Transformer) make_prefix(op flat.Op, expr flat.NodeId) flat.NodeId

make_prefix builds make prefix data for transform.

fn (mut t Transformer) make_selector(base flat.NodeId, field string, typ string) flat.NodeId

make_selector builds make selector data for transform.

fn (mut t Transformer) make_selector_op(base flat.NodeId, field string, typ string, op flat.Op) flat.NodeId

make_selector_op builds make selector op data for transform.

fn (mut t Transformer) make_sizeof_type(type_name string) flat.NodeId

make_sizeof_type builds make sizeof type data for transform.

fn (mut t Transformer) make_string_literal(value string) flat.NodeId

make_string_literal builds make string literal data for transform.

fn (mut t Transformer) make_struct_init(name string) flat.NodeId

make_struct_init builds make struct init data for transform.

fn (mut t Transformer) make_sum_tag_selector(base flat.NodeId, op flat.Op) flat.NodeId

make_sum_tag_selector builds an internal selector for a sumtype discriminator.

fn (mut t Transformer) new_temp(prefix string) string

new_temp supports new temp handling for Transformer.

fn (mut t Transformer) pop_smartcast()

pop_smartcast updates pop smartcast state for Transformer.

fn (mut t Transformer) push_smartcast(expr_name string, variant string, sum_type string)

push_smartcast updates push smartcast state for Transformer.

fn (mut t Transformer) synthesize_sum_eq_helpers() []string

synthesize_sum_eq_helpers generates the fn_decl for every sum type whose equality helper was requested during the transform. Building one helper body can request helpers for nested sum types, so this drains a worklist. Runs serially on the merged AST (workers only record names). Returns the names newly marked used while building the helper bodies (e.g. a payload struct's overloaded ==), so the caller can run them through the late-used-fn pass — synthesis happens after that pass, so such functions would otherwise miss body transformation.

fn (mut t Transformer) transform_expr(id flat.NodeId) flat.NodeId

transform_expr transforms transform expr data for transform.

fn (mut t Transformer) transform_lvalue(id flat.NodeId) flat.NodeId

transform_lvalue transforms transform lvalue data for transform.

fn (mut t Transformer) transform_stmt(id flat.NodeId) []flat.NodeId

transform_stmt transforms transform stmt data for transform.

fn (mut t Transformer) transform_stmts(ids []flat.NodeId) []flat.NodeId

transform_stmts transforms transform stmts data for transform.