v3.transform

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

--- entry point ---

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

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")
}

struct StructInfo {
pub:
	name   string
	module string
	fields []FieldInfo
}

struct Transformer {
mut:
	a               &flat.FlatAst      = unsafe { nil }
	tc              &types.TypeChecker = unsafe { nil }
	structs         map[string]StructInfo
	globals         map[string]string
	sum_types       map[string][]string
	fn_ret_types    map[string]string
	enum_types      map[string][]string
	cur_file        string
	cur_module      string
	cur_fn_name     string
	cur_fn_ret_type string
	var_types       []VarTypeBinding
	temp_counter    int
	pending_stmts   []flat.NodeId
	smartcast_stack []SmartcastContext
}

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

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

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

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

--- public query helpers ---

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

--- helper methods ---

fn (mut t Transformer) pop_smartcast()

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

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

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

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

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

--- statement list driver ---