v3.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 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 unwrap_pointer(t Type) Type

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

fn Properties.zero() Properties

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

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

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

fn (t Type) is_pointer() bool

fn (t Type) is_string() bool

fn (t Type) is_integer() bool

fn (t Type) is_float() bool

fn (t Type) name() string

enum Properties {
	boolean
	float
	integer
	unsigned
	untyped
}

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
	unhandled_node
	unsupported_generic
}

struct Alias {
pub:
	name      string
	base_type Type
}

struct Array {
pub:
	elem_type Type
}

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

struct Char {
	dummy_ u8
}

struct Enum {
pub:
	name    string
	is_flag bool
}

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

struct ISize {
	dummy_ u8
}

struct Interface {
pub:
	name string
}

struct Map {
pub:
	key_type   Type
	value_type Type
}

struct MultiReturn {
pub:
	types []Type
}

struct Nil {
	dummy_ u8
}

struct None {
	dummy_ u8
}

struct OptionType {
pub:
	base_type Type
}

struct Pointer {
pub:
	base_type Type
}

struct Primitive {
pub:
	props Properties
	size  u8
}

struct ResultType {
pub:
	base_type Type
}

struct Rune {
	dummy_ u8
}

struct Scope {
pub mut:
	parent &Scope = unsafe { nil }
	names  []string
	types  []Type
}

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 (mut s Scope) insert(name string, typ Type)

insert records or updates a type binding in this scope.

struct String {
	dummy_ u8
}

struct Struct {
pub:
	name string
}

struct StructField {
pub:
	name string
	typ  Type
}

struct SumType {
pub:
	name string
}

struct TypeChecker {
pub mut:
	a                             &flat.FlatAst = unsafe { nil }
	fn_ret_types                  map[string]Type
	fn_param_types                map[string][]Type
	fn_variadic                   map[string]bool
	structs                       map[string][]StructField
	unions                        map[string]bool
	type_aliases                  map[string]string
	sum_types                     map[string][]string
	enum_names                    map[string]bool
	enum_fields                   map[string][]string
	flag_enums                    map[string]bool
	interface_names               map[string]bool
	interface_fields              map[string][]StructField
	interface_embeds              map[string][]string
	const_types                   map[string]Type
	const_exprs                   map[string]flat.NodeId
	const_modules                 map[string]string
	imports                       map[string]string // alias -> short module name
	file_imports                  map[string]string
	file_modules                  map[string]string
	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
	errors                        []TypeError
	resolved_call_names           []string // node_id -> resolved function name
	resolved_call_set             []bool
	expr_type_values              []Type // node_id -> complex/contextual resolved type
	expr_type_set                 []bool
	diagnose_unknown_calls        bool
	reject_unlowered_map_mutation bool
	diagnostic_files              map[string]bool
	cur_fn_ret_type               Type = Type(void_)
	smartcasts                    map[string]Type
}

fn (mut tc TypeChecker) push_scope()

fn (mut tc TypeChecker) pop_scope()

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

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

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

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 (tc &TypeChecker) expr_type(id flat.NodeId) ?Type

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

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

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

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) check_semantics()

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

parse_type converts a V type string (from parser) to a structured Type.

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

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

struct TypeError {
pub:
	msg  string
	kind TypeErrorKind
	node flat.NodeId
}

struct USize {
	dummy_ u8
}

struct Unknown {
pub:
	reason string
}

struct Void {
	dummy_ u8
}