v3.types #

Type aliases type values used by types.

fn builtin_type(name string) ?Type

builtin_type returns the Type for a builtin type name, or none otherwise.

fn builtin_type_value(name string) Type

builtin_type_value returns the Type for a known builtin type name.

fn clone_owned_type(value Type) Type

clone_owned_type clones a type and all nested owned metadata.

fn clone_owned_types(values []Type) []Type

clone_owned_types clones a list of types and all nested owned metadata.

fn defer_result_index(node flat.Node) ?int

defer_result_index returns -1 for an unindexed $res() node and the non-negative index for a $res(index) node.

fn extend_stable_type_indexes(mut indexes map[string]int, type_names []string)

extend_stable_type_indexes assigns deterministic, collision-free runtime indexes to new names without changing indexes that have already been used during lowering.

fn extend_stable_type_indexes_ref(mut indexes map[string]int, type_names &[]string)

extend_stable_type_indexes_ref is the pointer-ABI form used by native compiler stages.

fn generic_base_name(name string) string

generic_base_name returns the declaration part of a concrete generic type name.

fn is_builtin_type_name(name string) bool

is_builtin_type_name reports whether name is one of V's builtin type names.

fn new_scope(parent &Scope) &Scope

new_scope returns a reusable type-checker scope with an optional parent.

fn stable_interface_type_ids(impl_names []string) map[string]int

stable_interface_type_ids assigns deterministic nonzero _typ dispatch IDs to interface implementers in caller-supplied order. Hash collisions are resolved with linear probing after earlier names keep their IDs, so late generic implementers appended after transform cannot shift IDs already emitted for existing interface values/checks.

fn stable_interface_type_ids_preserving_prefix(prefix []string, impl_names []string) map[string]int

stable_interface_type_ids_preserving_prefix assigns IDs for impl_names while keeping all prefix IDs exactly as they would be when assigned alone.

fn stable_type_index(name string) int

stable_type_index returns the deterministic nonzero runtime-index seed for a named type. Use stable_type_indexes when assigning indexes across a complete program type set.

fn stable_type_indexes(type_names []string) map[string]int

stable_type_indexes assigns deterministic, collision-free runtime indexes to the complete caller-supplied program type set.

fn type_text_contains_typeof(s string) bool

parse_type converts a V type string (from parser) to a structured Type. type_text_contains_typeof is a fast substring probe for typeof(: type texts are overwhelmingly short scalar/container names, so the length early-out plus a first-byte scan beats string.contains (KMP table build and call overhead) on hot paths that must screen every text.

fn unsigned_shift_result_type(t Type) Type

unsigned_shift_result_type returns the unsigned counterpart used as the result of >>>.

fn unwrap_all_pointers(t Type) Type

unwrap_all_pointers removes every pointer layer from t.

fn unwrap_pointer(t Type) Type

unwrap_pointer transforms unwrap pointer data for types.

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

fn Properties.zero() Properties

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

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

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

fn TypeChecker.new(a &flat.FlatAst) TypeChecker

new creates a TypeChecker value for types.

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

type SymbolId = u32

SymbolId is the stable identity of a resolved declaration name in one compilation. Zero denotes no symbol.

type Type = Void
	| Unknown
	| Primitive
	| String
	| Char
	| Rune
	| ISize
	| USize
	| Nil
	| None
	| Array
	| ArrayFixed
	| Channel
	| Map
	| Pointer
	| FnType
	| OptionType
	| ResultType
	| Struct
	| Interface
	| Enum
	| SumType
	| Alias
	| MultiReturn

fn (t Type) is_pointer() bool

is_pointer reports whether is pointer applies in types.

fn (t Type) is_string() bool

is_string reports whether is string applies in types.

fn (t Type) is_integer() bool

is_integer reports whether is integer applies in types.

fn (t Type) is_float() bool

is_float reports whether is float applies in types.

fn (t Type) name() string

name returns name data for Type.

type TypeId = u32

TypeId is the stable identity of a canonical semantic type in one compilation. Type values remain the public compatibility representation; caches and equality-heavy internals can use this compact identity.

enum Properties {
	boolean
	float
	integer
	unsigned
	untyped
}

Properties lists properties values used by types.

fn (e &Properties) all(flag_ Properties) bool

fn (mut e Properties) clear(flag_ Properties)

fn (mut e Properties) clear_all()

fn (e &Properties) has(flag_ Properties) bool

fn (e &Properties) is_empty() bool

fn (mut e Properties) set(flag_ Properties)

fn (mut e Properties) set_all()

fn (mut e Properties) toggle(flag_ Properties)

enum TypeErrorKind {
	unknown_ident
	unknown_type
	unknown_fn
	unknown_field
	cannot_index
	if_branch_mismatch
	assignment_mismatch
	return_mismatch
	call_arg_mismatch
	condition_mismatch
	duplicate_decl
	unhandled_node
	unsupported_generic
	compile_error
}

TypeErrorKind lists type error kind values used by types.

struct Alias {
pub:
	name      string
	base_type Type
}

Alias represents alias data used by types.

struct Array {
pub:
	elem_type Type
}

Array represents array data used by types.

struct ArrayFixed {
pub:
	elem_type Type
	len       int
	len_expr  string
}

ArrayFixed represents array fixed data used by types.

struct CallInfo {
pub:
	name                 string
	params               []Type
	shared_params        []bool
	return_type          Type
	has_receiver         bool
	is_variadic          bool
	is_c_variadic        bool
	params_known         bool
	has_implicit_veb_ctx bool
	arg_offset           int
}

CallInfo stores call info metadata used by types.

struct Channel {
pub:
	elem_type Type
	is_mut    bool
}

Channel represents channel data used by types.

struct Char {
	dummy_ u8
}

Char represents char data used by types.

struct Enum {
pub:
	name    string
	is_flag bool
}

Enum represents enum data used by types.

struct FnType {
pub:
	params      []Type
	return_type Type
}

FnType represents fn type data used by types.

struct ISize {
	dummy_ u8
}

ISize represents isize data used by types.

struct Interface {
pub:
	name string
}

Interface represents interface data used by types.

struct InterfaceImplIndex {
pub:
	names []string
	ids   map[string]int
}

struct Map {
pub:
	key_type   Type
	value_type Type
}

Map represents map data used by types.

struct MultiReturn {
pub:
	types []Type
}

MultiReturn represents multi return data used by types.

struct Nil {
	dummy_ u8
}

Nil represents nil data used by types.

struct None {
	dummy_ u8
}

None represents none data used by types.

struct OptionType {
pub:
	base_type Type
}

OptionType represents option type data used by types.

struct OwnershipDropEntry {
pub:
	name             string
	type_name        string
	optional_wrapper bool
}

struct Pointer {
pub:
	base_type Type
}

Pointer represents pointer data used by types.

struct Primitive {
pub:
	props Properties
	size  u8
}

Primitive represents primitive data used by types.

struct QualifyNameCache {
pub mut:
	module               string
	file                 string
	resolution_type_mode bool
	fingerprint          int = -1
	entries              map[string]string
	last_name            string
	last_value           string
	last_valid           bool
}

qualify_name supports qualify name handling for TypeChecker. QualifyNameCache memoizes qualify_name per source and type-resolution context. Its table fingerprint invalidates entries while collection is still growing the declared-type tables; every checker fork gets its own instance.

struct ResultType {
pub:
	base_type Type
}

ResultType represents result type data used by types.

struct Rune {
	dummy_ u8
}

Rune represents rune data used by types.

struct Scope {
pub mut:
	parent       &Scope = unsafe { nil }
	names        []string
	types        []Type
	name_indexes map[string]int
	// name_mask is a conservative bloom filter over this scope's own binding
	// names: a cleared bit proves the name is absent, letting chain walks skip
	// the per-level map probe (most lookups walk many levels that do not bind
	// the name at all). False positives only cost the probe they would have
	// paid anyway.
	name_mask       u64
	generations     []int
	storage_keys    []string
	next_generation int
	lifetime        int
}

Scope represents scope data used by types.

fn (mut s Scope) reset(parent &Scope)

reset retargets a pooled scope, clearing its bindings while keeping the backing storage capacity so reuse does not reallocate. Without this clear a pooled scope's arrays accumulate every binding ever inserted across all generations, turning lookup/insert into an O(n) scan over dead entries.

fn (s &Scope) lookup(name string) ?Type

lookup returns the nearest visible type binding for name.

fn (s &Scope) lookup_owner(name string) ?ScopeBindingOwner

lookup_owner returns the nearest scope that owns a visible binding for name.

fn (s &Scope) nearest_binding_owned_by(name string, owner ScopeBindingOwner) bool

nearest_binding_owned_by reports whether the nearest visible binding for name belongs to owner.

fn (mut s Scope) insert(name string, typ Type)

insert records or updates a type binding in this scope.

fn (mut s Scope) insert_with_owner(name string, typ Type) ScopeBindingOwner

insert_with_owner records or updates a type binding and returns the exact binding identity now visible for name.

struct ScopeBindingOwner {
	scope       &Scope = unsafe { nil }
	index       int    = -1
	generation  int
	lifetime    int
	name        string
	storage_key string
}

fn (owner ScopeBindingOwner) storage_key() string

storage_key returns a stable key for this binding owner while its scope is live.

fn (owner ScopeBindingOwner) belongs_to_scope(scope &Scope) bool

belongs_to_scope reports whether this binding owner was declared directly in scope.

fn (owner ScopeBindingOwner) belongs_to_scope_chain_until(scope &Scope, stop &Scope) bool

belongs_to_scope_chain_until reports whether this binding owner was declared between scope and stop, inclusive.

struct String {
	dummy_ u8
}

String represents string data used by types.

struct Struct {
pub:
	name string
}

Struct represents struct data used by types.

struct StructField {
pub:
	name        string
	typ         Type
	has_default bool
	is_embed    bool
	is_mut      bool
}

StructField represents struct field data used by types.

struct SumType {
pub:
	name string
}

SumType represents sum type data used by types.

struct TransformForkOverlay {
pub mut:
	resolved_call_names map[int]string
	resolved_fn_values  map[int]string
}

TransformForkOverlay holds the call/fn-value resolutions a parallel-transform worker records for its transform-created (cloned) nodes. It lives on the heap (like TypeCache) so a worker's &TypeChecker fork can write through the pointer without mutating the shared node-indexed arrays; reads consult the overlay before those arrays, and merge_worker replays the entries into the master under the shifted node ids.

struct TypeCacheStats {
pub:
	parse_hits   i64
	parse_misses i64
	c_hits       i64
	c_misses     i64
}

TypeCacheStats reports semantic cache effectiveness for compiler telemetry.

struct TypeChecker {
pub mut:
	a                            &flat.FlatAst = unsafe { nil }
	verbose                      bool
	enable_globals               bool
	fn_ret_types                 map[string]Type
	fn_param_types               map[string][]Type
	c_fn_module_ret_types        map[string]Type
	c_fn_module_param_types      map[string][]Type
	c_fn_module_variadic         map[string]bool
	fn_shared_params             map[string][]bool
	mut_receiver_methods         map[string]bool
	source_no_body_fns           map[string]bool
	source_no_body_fn_suffixes   map[string]bool
	unsafe_fns                   map[string]bool
	unsafe_c_fns                 map[string]bool
	fn_ret_type_texts            map[string]string   // generic struct method key -> original return type text (e.g. `Box[T].clone` -> `Box[T]`)
	fn_param_type_texts          map[string][]string // generic struct method key -> original param type texts (receiver first)
	fn_type_files                map[string]string
	fn_type_modules              map[string]string
	fn_generic_params            map[string][]string
	specialized_generic_fns      map[string]bool
	fn_variadic                  map[string]bool
	c_variadic_fns               map[string]bool
	fn_implicit_veb_ctx          map[string]bool
	receiver_method_suffix_index map[string]string
	structs                      map[string][]StructField
	struct_modules               map[string]string
	struct_files                 map[string]string
	soa_structs                  map[string]bool
	// set of `${file}\x01${module}\x01${name}` keys for every source-level
	// struct/type/interface/enum declaration, built once in `collect`. Replaces
	// the former full-node scan in `source_declares_type_in_scope`, which was
	// O(nodes) per call and dominated check/transform/cgen (called via qualify_name).
	declared_type_scope_keys           map[string]bool
	struct_error_embeds_shadow_builtin map[string]bool
	struct_generic_params              map[string][]string // generic struct base name -> type-param names (e.g. Vec4 -> [T])
	struct_implements                  map[string][]string
	struct_shared_fields               map[string]bool
	struct_field_c_abi_fns             map[string]string
	// concrete `Box[int].method` -> substituted CallInfo for a method *value* on a
	// generic receiver. The open `Box[T].method` registration is gone by cgen time, so
	// the checker stashes the resolved signature here for gen_method_value_closure.
	generic_method_value_info             map[string]CallInfo
	params_structs                        map[string]bool
	c_typedef_structs                     map[string]bool
	unions                                map[string]bool
	type_aliases                          map[string]string
	type_alias_generic_params             map[string][]string // generic alias base name -> type-param names
	type_alias_c_abi_fns                  map[string]string
	recursive_alias_names                 map[string]bool
	sum_types                             map[string][]string
	sum_generic_params                    map[string][]string // generic sum type base name -> type-param names (e.g. Tree -> [T])
	enum_names                            map[string]bool
	enum_fields                           map[string][]string
	flag_enums                            map[string]bool
	interface_names                       map[string]bool
	interface_generic_params              map[string][]string
	interface_fields                      map[string][]StructField
	interface_embeds                      map[string][]string
	interface_abstract_methods            map[string][]string // iface -> abstract (declared) method names
	interface_impl_name_snapshots         map[string][]string
	interface_impl_candidates_at_snapshot map[string]bool
	interface_impl_candidates_at_index    map[string]bool
	interface_method_names_index          map[string][]string
	interface_abstract_index              map[string][]string
	interface_field_list_index            map[string][]StructField
	interface_impl_indexes                map[string]&InterfaceImplIndex
	interface_query_indexes_ready         bool

	c_globals               map[string]Type
	global_names            map[string]bool
	const_types             map[string]Type
	const_exprs             map[string]flat.NodeId
	const_modules           map[string]string
	const_files             map[string]string
	const_suffixes          map[string]string // dot-suffix -> full const key (O(1) lookup; '' if ambiguous)
	declaration_visibility  map[string]DeclarationVisibility
	checked_const_names     map[string]bool
	imports                 map[string]string // alias -> short module name
	file_imports            map[string]string
	file_selective_imports  map[string][]string
	file_imports_by_file    map[string]&FileImportInfo
	file_modules            map[string]string
	translated_files        map[string]bool
	has_globals_files       map[string]bool
	deprecated_symbols      map[string]DeprecationInfo
	file_scope              &Scope = unsafe { nil }
	cur_scope               &Scope = unsafe { nil }
	scope_pool              []&Scope
	scope_pool_index        int
	has_builtins            bool
	cur_module              string
	cur_file                string
	unsafe_depth            int
	lock_depth              int
	errors                  []TypeError
	notices                 []TypeError
	resolved_call_names     []string // node_id -> resolved function name
	resolved_call_set       []bool
	resolved_fn_value_names []string // node_id -> resolved function value name
	resolved_fn_value_set   []bool
	statement_nodes         []bool
	// Exact call/function-value dependencies recorded while each function is
	// checked. Consumers such as markused can walk these resolved Symbol-like
	// names instead of reconstructing import and receiver resolution from syntax.
	direct_dependencies_by_fn map[int][]SymbolId // enclosing fn node id -> resolved function identities
	// Methods used as *values* (`recv.method` passed as a callback), recorded per enclosing
	// function during semantic checking — which has full scope/type info, runs before
	// markused, and (unlike a call) routes a value-context selector through check_selector.
	// markused seeds these (keeping the wrapper-only method out of the dead-code pruner)
	// only when their enclosing function is reachable.
	method_values_by_fn map[int][]string // enclosing fn node id -> method-value `Type.method` keys
	// Local variables bound to a method value (`cb := c.report`) in the current function.
	// Escape checks use these aliases to retain the lifetime hazard of mutable methods
	// borrowing addressable stack receivers. Reset per function.
	method_value_locals map[string]bool
	// Scope depth at which each method-value local was marked, so a reassignment to a
	// non-method value only clears the marker when it dominates later uses (same-or-shallower
	// scope); a reassignment in a deeper conditional/loop scope keeps the maybe-method marker.
	method_value_local_depth                map[string]int
	capturing_fn_literal_locals             map[string]bool
	capturing_fn_literal_local_depth        map[string]int
	capturing_fn_literal_return_unsupported map[string]bool
	cur_fn_node_id                          int = -1
	cur_fn_mut_param_base_types             map[string]Type
	cur_fn_mut_param_binding_owners         map[string]ScopeBindingOwner
	cur_fn_mut_local_binding_owners         map[string]ScopeBindingOwner
	cur_fn_shared_binding_owners            map[string]ScopeBindingOwner
	cur_comptime_variant_loop_vars          []string
	expr_type_values                        []Type // node_id -> complex/contextual resolved type
	expr_type_set                           []bool
	checking_nodes                          []bool
	parallel_check_sparse                   bool
	scope_parallel_check_workers            bool
	// Node id range [check_range_lo, check_range_hi] of the fn item currently
	// being checked. Fn subtrees are disjoint contiguous ranges (each fn_decl at
	// index i owns (prev_top_level_idx, i]), so while parallel_check_sparse is
	// set, cache entries for in-range ids are written straight into the shared
	// node-indexed arrays (this checker is the range's only writer) and only
	// out-of-range ids (consts, other decls' nodes) go through the private
	// sparse maps that are merged after join.
	check_range_lo                int = -1
	check_range_hi                int = -1
	sparse_resolved_call_names    map[int]string
	sparse_resolved_fn_values     map[int]string
	sparse_statement_nodes        map[int]bool
	sparse_expr_type_values       map[int]Type
	sparse_checking_nodes         map[int]bool
	diagnose_unknown_calls        bool
	reject_unlowered_map_mutation bool
	reject_unsupported_generics   bool
	checker_fixture_mode          bool
	suppress_dump_output          bool
	diagnostic_files              map[string]bool
	multiple_module_import_lines  map[u64]bool
	source_texts_by_file          map[string]string
	has_spawn_expr                int = -1
	inactive_top_level_node_ids   []int
	selected_file_called_fns      map[string]bool
	// Names newly inserted into selected_file_called_fns and not yet chased by
	// the transitive closure in collect_selected_file_called_fns_transitively.
	selected_file_worklist []string
	// During the parallel check region the called-fns closure is computed on its
	// own thread, so `selected_file_called_fns` is not yet available. Sites that
	// would gate on it park their candidate error here instead; the master
	// filters the list against the finished set after joining the thread.
	defer_ierror_gating   bool
	pending_ierror_errors []PendingIerrorError
	// Node indices of every top-level declaration node (file markers, module/import
	// decls, type-level decls, consts, globals, fn/c-fn decls), in AST order. These
	// kinds only occur at the top level, so a pass iterating this index visits the
	// same nodes in the same order as a full `a.nodes` scan that matches on them —
	// without streaming the ~100x larger node array each time. Built once in
	// `collect`; no later phase of the check step appends declarations. Phases
	// after the check (transform) may grow the AST: top_level_idx_nodes_len
	// records the node count the index covers.
	top_level_idx           []int
	top_level_idx_nodes_len int
	expected_expr_id        int  = -1
	expected_expr_type      Type = Type(void_)
	cur_fn_ret_type         Type = Type(void_)
	channel_send_or_expr_id int  = -1
	smartcasts              map[string]Type
	ownership               &OwnershipState = unsafe { nil }
	// See QualifyNameCache: nil unless armed for a phase whose allocations
	// outlive every prealloc scope arena; forks must replace it with their own
	// instance. A long-lived armed cache written during a scoped driver stage
	// (markused/transform/cgen under -prealloc) stores map buckets and result
	// strings in the disposable scope arena, and later reads crash.
	qualify_name_cache &QualifyNameCache = unsafe { nil }
	// Per-fork resolve_type memo for the current check work item's node range;
	// nil until check_fn_items_serial arms it (see BodyResolveMemo).
	body_resolve_memo &BodyResolveMemo = unsafe { nil }
	import_info_cache &ImportInfoCache = unsafe { nil }
	// Nanoseconds spent in the ownership checker's per-fn boundary passes.
	// Only `-d ownership` builds ever write it (every writer lives in
	// checker_ownership_d_ownership.v), so plain builds report exactly 0.
	ownership_time_ns i64
	selfhost          bool
	// resolution_type_mode is enabled only after semantic checking, while transform
	// and codegen read synthesized generic-specialization type text. Source annotations
	// must keep normal module scoping and never enable this fallback.
	resolution_type_mode bool
	// fork_overlay is non-nil only on parallel-transform worker forks; see
	// TransformForkOverlay and fork_for_parallel_transform.
	fork_overlay &TransformForkOverlay = unsafe { nil }
mut:
	// Includes method-value aliases and binding-owner maps; all backing maps are
	// replaced together at every function/worker boundary.
	fn_context               FunctionCheckContext
	type_cache               &TypeCache               = unsafe { nil }
	pre_transform_type_cache &TypeCache               = unsafe { nil }
	resolution_type_views    &ResolutionTypeViewCache = unsafe { nil }
	visible_mutation_cache   &VisibleMutationCache    = unsafe { nil }
	type_interner            &TypeInterner            = unsafe { nil }
	symbols                  &SymbolInterner          = unsafe { nil }
	// direct_parent_ids maps a parsed node to the first AST node that references
	// it as a child. It is immutable during semantic checking and shared by
	// checker workers. Transformed or appended nodes use the scan fallback in
	// direct_parent_id.
	direct_parent_ids           []flat.NodeId
	direct_parent_index_trusted bool
	has_goto_nodes              bool
	// Immutable declaration indexes shared by checker workers.
	declaration_attributes       map[int][]string
	type_declaration_ids         map[string][]int
	strings_builder_bindings     map[string]bool
	static_associated_fn_keys    map[string]bool
	declaration_param_mutability map[string][]bool
	strict_map_index_files       map[string]bool
	// short fn name -> first declaring top-level node index, in declaration
	// order (mirrors the expr_raw_fn_type_text scan's first-match rule).
	fn_decl_short_name_ids map[string]int
	// '${file}\x00${alias}' -> dotted import path, and '${file}\x00${last
	// segment}' -> dotted import path (first import wins), replacing per-call
	// scans over every top-level declaration.
	file_import_alias_paths  map[string]string
	file_import_suffix_paths map[string]string
	// struct name -> embedded receiver type names (empty entry when the struct
	// has no embeds). Structs added after collect (monomorphization) miss this
	// index and fall back to the field walk.
	struct_embed_receivers map[string][]string
	// Immutable node -> generic parameter index shared by checker workers.
	enclosing_generic_params_by_node map[int][]string
	enclosing_generic_param_masks    []u32
}

TypeChecker represents type checker data used by types.

fn (mut tc TypeChecker) annotate_types()

annotate_types performs a scope-aware walk over every function body, tracking local variable types as they are declared, and records complex/contextual expression types. This mirrors what the v2 transformer relies on: the type checker runs BEFORE the transformer and publishes per-expression types, so the transformer can own type-dependent lowering (string ops, in membership, ...) instead of the backend.

It uses a single flat scope per function (an over-approximation: a local stays visible after its block ends), which is harmless for type lookup since variable names are effectively unique within a function.

fn (mut tc TypeChecker) annotate_types_with_used(used_fns map[string]bool)

annotate_types_with_used annotates only functions that can be emitted when used_fns is non-empty. This mirrors transform/cgen pruning and avoids resolving types in dead, untransformed function bodies after markused.

fn (mut tc TypeChecker) begin_sparse_transform_node_caches(base_nodes int)

begin_sparse_transform_node_caches keeps source-node entries in their dense checked arrays and records transform-created node metadata sparsely.

fn (tc &TypeChecker) c_type(t Type) string

c_type supports c type handling for TypeChecker.

fn (tc &TypeChecker) cached_c_name(name string) string

cached_c_name memoizes naming.c_name results in the type cache (falling back to the frozen base cache read-only, like every other entry kind). c_name is pure and called on hot resolution paths in every phase.

fn (tc &TypeChecker) canonical_qualified_type_name(name string) ?string

canonical_qualified_type_name resolves a possibly bare or partially qualified type name (e.g. PoolProcessor or pool.PoolProcessor) to its unique fully qualified spelling (sync.pool.PoolProcessor). It returns none when the name is unknown or when the short name is ambiguous across modules. Backends use this to rebuild method/type C names when a receiver type carries only the import-local module qualifier instead of the full module path.

fn (tc &TypeChecker) canonical_symbol(name string) string

canonical_symbol returns the compilation-owned canonical spelling of name.

fn (mut tc TypeChecker) check_concrete_fn_semantics(fn_idx int, file string, module_name string)

check_concrete_fn_semantics validates a concrete generic function clone before the transformer lowers its body. The clone retains source positions, so errors use the normal checker renderer instead of positionless transform diagnostics.

fn (mut tc TypeChecker) check_interface_embedding_limits() bool

check_interface_embedding_limits rejects deep interface casts before requirement indexes recursively expand the embedding chain.

fn (mut tc TypeChecker) check_main_module_requirement(is_shared bool)

check_main_module_requirement rejects ordinary programs that contain no selected source file in the main module.

fn (mut tc TypeChecker) check_semantics()

check_semantics validates check semantics state for types.

fn (mut tc TypeChecker) check_semantics_opt(want_parallel bool) bool

check_semantics_opt runs semantic checks, using worker threads for independent function bodies when requested and there is enough work.

fn (mut tc TypeChecker) check_semantics_reachable(selected map[string]bool)

check_semantics_reachable validates only selected function declarations and bodies, plus top-level statements in the selected input. It is intended for source shapes that have already proven they cannot declare any other items.

fn (mut tc TypeChecker) check_semantics_selected(selected map[string]bool)

check_semantics_selected validates declarations and only the named function bodies. It is used by the function-level incremental compiler after it has proven that every top-level declaration is unchanged.

fn (tc &TypeChecker) clear_c_type_cache()

clear_c_type_cache invalidates C spellings after monomorphization changes concrete type identities and adds materialized generic types.

fn (tc &TypeChecker) clear_field_lookup_cache()

fn (tc &TypeChecker) clear_interface_impl_cache()

clear_interface_impl_cache invalidates memoized implementer lists after a type-table change.

fn (mut tc TypeChecker) clear_resolved_fn_value(id flat.NodeId)

clear_resolved_fn_value removes stale function-value metadata after a later transform proves that an identifier refers to a value declaration.

fn (mut tc TypeChecker) collect(a &flat.FlatAst)

fn (tc &TypeChecker) concrete_method_signature_key(concrete_name string, method string) ?string

fn (tc &TypeChecker) const_int_value(name string, seen []string) ?int

const_int_value supports const int value handling for TypeChecker.

fn (tc &TypeChecker) const_int_value_in_module(name string, module_name string, seen []string) ?int

const_int_value_in_module supports const int value handling for a specific module.

fn (tc &TypeChecker) const_owner_module(name string) string

const_owner_module returns the declaration module for a checker-resolved constant key.

fn (mut tc TypeChecker) copy_cloned_resolution(src_id flat.NodeId, dst_id flat.NodeId)

copy_cloned_resolution copies checker-owned call/function-value resolution metadata from an original node to a transform-created clone.

fn (mut tc TypeChecker) diagnose_unused_private_declarations(used_fns map[string]bool)

diagnose_unused_private_declarations records notices for unreachable private functions and constants that are never referenced by any declaration.

fn (tc &TypeChecker) direct_dependencies(fn_node_id int) []string

direct_dependencies returns canonical dependency names for compatibility.

fn (tc &TypeChecker) direct_dependency_ids(fn_node_id int) []SymbolId

direct_dependency_ids returns the checker-resolved function dependency identities of a function declaration node. The slice is read-only.

fn (mut tc TypeChecker) disable_resolution_type_view_cache()

disable_resolution_type_view_cache prevents a scoped cache from escaping the phase that allocated it.

fn (mut tc TypeChecker) enable_scoped_parallel_workers()

enable_scoped_parallel_workers uses disposable prealloc arenas for parallel checker helpers. Ownership checking keeps its existing long-lived workers.

fn (tc &TypeChecker) expr_is_method_value(id flat.NodeId) bool

expr_is_method_value reports whether id is a selector that resolves to a method value — a struct/interface method used as a value (obj.draw), not a field access or a method call. cgen backs such values with per-instance closure contexts.

fn (tc &TypeChecker) expr_type(id flat.NodeId) ?Type

expr_type returns the resolved type recorded for a node during annotate_types.

fn (tc &TypeChecker) fixed_array_len_value(arr ArrayFixed) ?int

fixed_array_len_value returns the evaluated fixed-array length when it can be resolved.

fn (tc &TypeChecker) fn_body_definitely_returns(node flat.Node) bool

fn_body_definitely_returns supports fn body definitely returns handling for TypeChecker.

fn (tc &TypeChecker) fn_param_types_for_name(name string) []Type

fn_param_types_for_name returns the collected parameter types for a resolved call name.

fn (tc &TypeChecker) fork_for_parallel_codegen() &TypeChecker

fork_for_parallel_codegen returns a complete read-only semantic view with private scope and memoization state for one C-generation worker.

fn (tc &TypeChecker) fork_for_parallel_transform(ast &flat.FlatAst) &TypeChecker

fork_for_parallel_transform returns a TypeChecker that shares all of tc's read-only data (semantic maps and node-indexed cache arrays, which the transform pass only reads) but owns a fresh, private type_cache and a private AST view. During transform the only hidden mutation a TypeChecker performs through its & receiver is memoization into type_cache (parse_type / c_type); giving each worker its own cache makes concurrent use race-free without cloning the large semantic maps. ast must be the worker's own (cloned) FlatAst so that any expr_type lookup on a freshly-created node id indexes a valid array.

fn (mut tc TypeChecker) free_parallel_transform_caches()

free_parallel_transform_caches releases private memoization maps owned by a forked transform checker and leaves it valid if it is accidentally read again.

fn (mut tc TypeChecker) freeze_interface_impl_names()

freeze_interface_impl_names snapshots the interface implementation order used by transform-generated _typ checks before later metadata cleanup can remove unused generic declarations and shift cgen's ids.

fn (mut tc TypeChecker) freeze_pre_transform_interface_impl_names()

freeze_pre_transform_interface_impl_names freezes the immutable implementer indexes prepared before transform. Transform does not add declarations; later generic implementers remain discoverable because the matching candidate set is frozen with the indexes.

fn (tc &TypeChecker) freeze_type_cache_for_forks()

freeze_type_cache_for_forks freezes this checker's warm type cache as the shared read-only base for parallel forks (fork_for_parallel_transform picks it up) and switches the checker itself to a private overlay so its own memoization writes cannot race fork reads. Callable on a shared reference: the transformer holds the checker as &TypeChecker.

fn (tc &TypeChecker) generic_type_name_matches(a string, b string) bool

fn (tc &TypeChecker) has_fn_decl_short_name(name string) bool

has_fn_decl_short_name reports whether collection indexed a function declaration with the given unqualified name.

fn (tc &TypeChecker) ierror_impl_names() []string

ierror_impl_names returns the concrete struct names that can be boxed as IError.

fn (tc &TypeChecker) index_operator_call_info(base_type Type, op string) ?CallInfo

fn (tc &TypeChecker) index_overload_call_info(typ Type, setter bool) ?CallInfo

fn (mut tc TypeChecker) inherit_ownership_codegen_metadata_from(_ &TypeChecker)

fn (tc &TypeChecker) interface_abstract_method_names(iface_name string) []string

interface_abstract_method_names returns the methods an implementer must provide: the interface's own declared (abstract) methods plus those of any embedded interfaces. Default methods defined directly on the interface are excluded.

fn (tc &TypeChecker) interface_accepts_implicit_str(iface_name string) bool

fn (tc &TypeChecker) interface_concrete_method_keys() []string

interface_concrete_method_keys returns generated interface dispatch methods and concrete method declarations that can be called by those dispatch functions.

fn (tc &TypeChecker) interface_field_list(iface_name string) []StructField

interface_field_list supports interface field list handling for TypeChecker.

fn (tc &TypeChecker) interface_impl_names(iface_name string) []string

interface_impl_names returns the concrete type names (structs and type aliases) that implement iface_name. Once a snapshot is frozen, its names stay first so transform-emitted interface IDs are preserved; later implementers are appended in deterministic discovery order.

fn (tc &TypeChecker) interface_impl_set_signature() string

interface_impl_set_signature returns the complete deterministic interface implementer set that controls collision-resolved dispatch IDs for the current program.

fn (tc &TypeChecker) interface_implements_interface(actual_name string, expected_name string) bool

interface_implements_interface supports interface implements interface handling for TypeChecker.

fn (tc &TypeChecker) interface_metadata_name(name string) string

fn (tc &TypeChecker) interface_method_signature_key(iface_name string, method string) ?string

fn (tc &TypeChecker) interface_type_ids(iface_name string) map[string]int

interface_type_ids returns the _typ dispatch IDs for an interface, preserving any snapshot IDs emitted before late generic implementers were discovered.

fn (tc &TypeChecker) invalidate_short_type_name_index()

invalidate_short_type_name_index drops memoized type-name-derived indexes; callers that add or remove entries in the type-name maps after the checker ran (the monomorphizer specializing generic structs/sum types) must invalidate them.

fn (tc &TypeChecker) is_locally_declared_bare_type(name string) bool

is_locally_declared_bare_type reports whether the bare name is a type declared in the current program (main module), which is bare-keyed in the type tables. Such a name denotes that local type, not an unqualified spelling of some other module's type.

fn (tc &TypeChecker) iterator_for_in_elem_type(typ Type) ?Type

fn (tc &TypeChecker) iterator_for_in_next_call_info(typ Type) ?CallInfo

fn (tc &TypeChecker) iterator_for_in_next_call_info_text(type_text string) ?CallInfo

iterator_for_in_next_call_info_text returns the specialized next call metadata for an iterator type.

fn (mut tc TypeChecker) materialize_sparse_transform_node_caches(n int, capacity int)

materialize_sparse_transform_node_caches compacts transform-created semantic entries into dense node-indexed arrays and reserves their expected final capacity before monomorphization appends more nodes.

fn (tc &TypeChecker) multi_expr_tail_types_for_transform(expr_id flat.NodeId, count int) ?[]Type

multi_expr_tail_types_for_transform returns promoted multi-expression tail types for transform lowering without duplicating checker compatibility rules.

fn (tc &TypeChecker) named_type_compatible_with_ierror(concrete_name string) bool

fn (tc &TypeChecker) named_type_implements_interface(concrete_name string, iface_name string) bool

named_type_implements_interface supports helper handling in types.

fn (tc &TypeChecker) named_type_implements_marker(concrete_name string, target string) bool

fn (tc &TypeChecker) ownership_default_clone_missing_method(_ Type) ?string

fn (tc &TypeChecker) ownership_drop_entries_at_fn_exit(_ string) []OwnershipDropEntry

fn (tc &TypeChecker) ownership_drop_entries_at_loop_control(_ string, _ int) []OwnershipDropEntry

fn (tc &TypeChecker) ownership_drop_entries_at_loop_iteration(_ string, _ int) []OwnershipDropEntry

fn (tc &TypeChecker) ownership_drop_entries_at_propagation(_ string, _ int) []OwnershipDropEntry

fn (tc &TypeChecker) ownership_drop_entries_at_return(_ string, _ int) []OwnershipDropEntry

fn (tc &TypeChecker) ownership_drop_entries_at_return_node(_ string, _ flat.NodeId) []OwnershipDropEntry

fn (tc &TypeChecker) ownership_drop_entries_at_scope_exit(_ string, _ int) []OwnershipDropEntry

fn (tc &TypeChecker) ownership_drop_type_names() []string

fn (tc &TypeChecker) ownership_drop_value_type_names() []string

fn (tc &TypeChecker) ownership_expr_creates_owned_value(_ flat.NodeId) bool

fn (tc &TypeChecker) ownership_expr_moves_storage(_ flat.NodeId, _ flat.NodeId) bool

fn (tc &TypeChecker) ownership_fn_value_returns_owned(_ flat.NodeId, _ string, _ string) bool

fn (tc &TypeChecker) ownership_index_read_moves_value(_ flat.NodeId) bool

fn (tc &TypeChecker) ownership_time_spent_us() i64

ownership_time_spent_us reports the accumulated ownership-analysis time for the dedicated benchmark stage. Compiled-out ownership (no -d ownership) cannot spend time, so this returns 0 by construction in plain builds.

fn (tc &TypeChecker) ownership_type_requires_destruction(_ Type) bool

fn (tc &TypeChecker) ownership_type_requires_drop(_ Type) bool

fn (tc &TypeChecker) parse_canonical_type(typ string) Type

parse_canonical_type parses compiler-produced type text while preserving an exact known qualified symbol before consulting the current file's import aliases. Source text must continue to use parse_type, where aliases take precedence; this entry point is for semantic names carried between phases.

fn (tc &TypeChecker) parse_resolution_type(typ string) Type

parse_resolution_type parses type text that can mix declaration-local names with concrete generic arguments from another module.

fn (tc &TypeChecker) parse_type(typ string) Type

fn (mut tc TypeChecker) pop_scope()

pop_scope updates pop scope state for TypeChecker.

fn (tc &TypeChecker) pre_transform_interface_impl_names(iface_name string) ?[]string

pre_transform_interface_impl_names returns the immutable implementer snapshot prepared after semantic checking and before generic monomorphization.

fn (tc &TypeChecker) precompute_source_error_embed_index()

precompute_source_error_embed_index builds the immutable source-error embedding index once before parallel consumers fork their private memoization overlays.

fn (mut tc TypeChecker) prepare_interface_query_indexes()

prepare_interface_query_indexes publishes immutable interface requirements and implementer lists for transform workers.

fn (mut tc TypeChecker) prepare_interface_requirement_indexes()

prepare_interface_query_indexes publishes immutable interface requirements for transform workers. Interface declarations no longer change after semantic checking, so compatibility scans can reuse these lists safely across threads.

fn (mut tc TypeChecker) prepare_threads_condition()

prepare_threads_condition caches whether selected inputs or their reachable imports use spawn.

fn (mut tc TypeChecker) promote_scoped_transform_interners(type_start int, symbol_start int, scope voidptr)

promote_scoped_transform_interners moves additions made by a scoped transform into the current compilation arena before that scope is freed.

fn (tc &TypeChecker) prune_inactive_top_level_comptime(mut a flat.FlatAst)

prune_inactive_top_level_comptime removes declarations and expressions from inactive top-level compile-time branches after semantic checking and before later compiler stages.

fn (mut tc TypeChecker) push_scope()

push_scope updates push scope state for TypeChecker.

fn (tc &TypeChecker) qualify_fn_name(name string) string

qualify_fn_name supports qualify fn name handling for TypeChecker.

fn (tc &TypeChecker) qualify_name(name string) string

fn (mut tc TypeChecker) rebind_ast(a &flat.FlatAst)

rebind_ast updates the AST view after the driver clones transformed storage. All collected declaration/type metadata remains valid because cloning preserves node ids.

fn (mut tc TypeChecker) rebuild_scoped_transform_signature_maps()

rebuild_scoped_transform_signature_maps moves signature maps, keys, and nested type metadata into the current arena after a disposable transform scope has been left.

fn (mut tc TypeChecker) record_cgen_error_at(msg string, node flat.NodeId, source_id flat.NodeId, marker string)

record_cgen_error_at records a post-transform validation error with cgen severity.

fn (tc &TypeChecker) register_short_type_name(name string)

register_short_type_name extends an already-built short-name index after monomorphization adds a concrete type. A scoped transform must not rebuild the entire index from maps whose strings may belong to the checked arena.

fn (mut tc TypeChecker) register_synth_type(id flat.NodeId, typ Type)

register_synth_type records the type of a generated or transformed node.

fn (mut tc TypeChecker) reserve_scoped_transform_metadata(signature_headroom int)

reserve_scoped_transform_metadata keeps tables that receive escaping transform additions in the compilation arena in the common case while scratch allocations use a disposable arena. The signature maps are rebuilt after promotion, so this headroom is an optimization rather than an ownership requirement.

fn (mut tc TypeChecker) reserve_transform_node_caches(n int)

reserve_transform_node_caches reserves node-indexed semantic storage before a scoped transform starts, keeping the escaping slabs in the compilation arena.

fn (mut tc TypeChecker) reset_resolution_type_view_cache()

reset_resolution_type_view_cache discards lookup views that may have been created inside a completed scoped parallel phase.

fn (mut tc TypeChecker) reset_resolved_calls_for_reannotation()

reset_resolved_calls_for_reannotation discards pre-transform call-name bindings before the transformed AST is annotated again. The annotation walk resolves and records every reachable call against the final AST/signatures.

fn (mut tc TypeChecker) reset_type_interners()

reset_type_interners replaces semantic interners whose backing storage may have grown inside a disposable compiler-stage arena.

fn (tc &TypeChecker) resolve_any_selective_import_fn(name string) ?string

resolve_any_selective_import_fn resolves an unqualified selected function when every source file that selects the name agrees on the same declaration.

fn (tc &TypeChecker) resolve_generic_struct_method(type_name string, method string) ?CallInfo

resolve_type_name_for_method resolves resolve type name for method information for types. resolve_generic_struct_method resolves a method call on a generic-struct instance (e.g. Vec4[f32].r_sqrt). The method is registered against the generic form (Vec4[T].r_sqrt); this maps the instance's concrete type arguments onto the generic parameters and substitutes them into the method's signature, so the pre-transform checker accepts the call. The transformer's monomorphize pass later materialises the concrete method body.

fn (tc &TypeChecker) resolve_generic_sum_method(type_name string, method string) ?CallInfo

fn (tc &TypeChecker) resolve_ierror_payload_name(name string) string

resolve_ierror_payload_name resolves scoped Error/MessageError names before falling back to the builtin error structs.

fn (tc &TypeChecker) resolve_imported_type_text_in_file(typ string, file string) string

fn (tc &TypeChecker) resolve_type(id flat.NodeId) Type

fn (tc &TypeChecker) resolved_call_name(id flat.NodeId) ?string

resolved_call_name returns the checker-resolved function name for a call node.

fn (tc &TypeChecker) resolved_call_never_returns(id flat.NodeId) bool

resolved_call_never_returns reports whether a call node resolved to a known no-return function.

fn (tc &TypeChecker) resolved_fn_value_name(id flat.NodeId) ?string

resolved_fn_value_name returns the checker-resolved function name for a function value node.

fn (tc &TypeChecker) runtime_type_index_names() []string

runtime_type_index_names returns the canonical program type names that can participate in runtime interface/sum type_idx() lowering.

fn (tc &TypeChecker) scoped_parallel_workers_enabled() bool

scoped_parallel_workers_enabled reports whether compiler stages should use short-lived worker arenas with this checker.

fn (tc &TypeChecker) selector_const_type(node flat.Node) ?Type

selector_const_type returns the declared type for a selector const expression.

fn (mut tc TypeChecker) set_fresh_type_cache(parse_enabled bool)

set_fresh_type_cache attaches a new empty TypeCache. Parallel-cgen worker checkers use this so the lazily-built lookup indexes and memoizations work per worker instead of falling back to their uncached full scans.

fn (mut tc TypeChecker) set_fresh_type_cache_based_on(src &TypeChecker, parse_enabled bool)

set_fresh_type_cache_based_on attaches a new empty TypeCache that falls back read-only to src's frozen base cache (see freeze_type_cache_for_forks), so parallel-cgen workers start with every type memoized by the check/transform phases instead of re-deriving them from a cold cache.

fn (tc &TypeChecker) struct_field_c_abi_fn_ptr_type(struct_name string, field_name string) ?string

struct_field_c_abi_fn_ptr_type returns the C ABI function-pointer type for a struct field.

fn (tc &TypeChecker) struct_field_type_name(struct_name string, field_name string) ?string

struct_field_type_name returns the canonical type name for a struct field.

fn (tc &TypeChecker) struct_fields_for_type(struct_name string) []StructField

struct_fields_for_type returns the fields of struct_name, with generic parameters substituted when struct_name is a concrete generic instance.

fn (tc &TypeChecker) sum_variant_type_for_pattern(sum_name string, variant_name string) ?string

fn (tc &TypeChecker) symbol_count() int

symbol_count returns the number of resolved names interned by the checker.

fn (tc &TypeChecker) symbol_name(id SymbolId) string

symbol_name resolves a checker symbol identity to its canonical name.

fn (tc &TypeChecker) threads_condition_value() bool

threads_condition_value reports the cached $if threads condition, scanning lazily for direct TypeChecker users that do not run the regular compiler setup.

fn (tc &TypeChecker) type_cache_parse_enabled() bool

type_cache_parse_enabled reports whether parse_type memoization is enabled on this checker's type cache.

fn (tc &TypeChecker) type_cache_stats() TypeCacheStats

type_cache_stats returns cache counters accumulated by this checker.

fn (tc &TypeChecker) type_count() int

type_count reports the number of unique canonical semantic types observed by this compilation.

fn (tc &TypeChecker) type_has_implicit_str_method(name string) bool

fn (tc &TypeChecker) type_name(t Type) string

type_name lazily formats and memoizes the canonical spelling of a semantic type. Hot compiler paths should prefer this to repeated recursive Type.name construction.

fn (mut tc TypeChecker) type_text_implements_interface(actual_text string, iface_text string) bool

type_text_implements_interface reports whether a concrete type expression satisfies an interface type expression in the current checker module context.

fn (tc &TypeChecker) unfreeze_type_cache_after_forks()

unfreeze_type_cache_after_forks folds the private overlay back into the frozen base once every fork has been joined, and reattaches the base as the live cache.

fn (tc &TypeChecker) unregister_short_type_name(name string)

unregister_short_type_name removes an exact cached entry when a generic template is erased. Ambiguous entries stay conservative until the next compilation-wide index build.

struct TypeError {
pub:
	msg        string
	kind       TypeErrorKind
	node       flat.NodeId
	file       string
	node_kind  string
	node_value string
	node_pos   string
	pos        token.Pos
	details    []string
	severity   string
}

TypeError represents type error data used by types.

struct USize {
	dummy_ u8
}

USize represents usize data used by types.

struct Unknown {
pub:
	reason string
}

Unknown represents unknown data used by types.

struct Void {
	dummy_ u8
}

Void represents void data used by types.