Remove allocator parameter to `types.cpp` functions

src/check_decl.cpp

@@ -231,7 +231,7 @@ void check_type_decl(Checker *c, Entity *e, AstNode *type_expr, Type *def) {
 	AstNode *te = remove_type_alias_clutter(type_expr);
 	e->type = t_invalid;
 	String name = e->token.string;
-	Type *named = make_type_named(c->allocator, name, nullptr, e);
+	Type *named = alloc_type_named(name, nullptr, e);
 	named->Named.type_name = e;
 	if (def != nullptr && def->kind == Type_Named) {
 		def->Named.base = named;
@@ -400,8 +400,8 @@ bool are_signatures_similar_enough(Type *a_, Type *b_) {
 		if (is_type_integer(x) && is_type_integer(y)) {
 			GB_ASSERT(x->kind == Type_Basic);
 			GB_ASSERT(y->kind == Type_Basic);
-			i64 sx = type_size_of(heap_allocator(), x);
-			i64 sy = type_size_of(heap_allocator(), y);
+			i64 sx = type_size_of(x);
+			i64 sy = type_size_of(y);
 			if (sx == sy) continue;
 		}
 
@@ -417,8 +417,8 @@ bool are_signatures_similar_enough(Type *a_, Type *b_) {
 		if (is_type_integer(x) && is_type_integer(y)) {
 			GB_ASSERT(x->kind == Type_Basic);
 			GB_ASSERT(y->kind == Type_Basic);
-			i64 sx = type_size_of(heap_allocator(), x);
-			i64 sy = type_size_of(heap_allocator(), y);
+			i64 sx = type_size_of(x);
+			i64 sy = type_size_of(y);
 			if (sx == sy) continue;
 		}
 
@@ -500,7 +500,7 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d) {
 	if (d->gen_proc_type != nullptr) {
 		proc_type = d->gen_proc_type;
 	} else {
-		proc_type = make_type_proc(c->allocator, e->scope, nullptr, 0, nullptr, 0, false, ProcCC_Odin);
+		proc_type = alloc_type_proc(e->scope, nullptr, 0, nullptr, 0, false, ProcCC_Odin);
 	}
 	e->type = proc_type;
 	ast_node(pl, ProcLit, d->proc_lit);

src/check_expr.cpp

@@ -56,7 +56,7 @@ void     check_expr_or_type             (Checker *c, Operand *operand, AstNode *
 ExprKind check_expr_base                (Checker *c, Operand *operand, AstNode *expression, Type *type_hint);
 void     check_expr_with_type_hint      (Checker *c, Operand *o, AstNode *e, Type *t);
 Type *   check_type                     (Checker *c, AstNode *expression, Type *named_type = nullptr);
-Type *   make_optional_ok_type          (gbAllocator a, Type *value);
+Type *   make_optional_ok_type          (Type *value);
 void     check_type_decl                (Checker *c, Entity *e, AstNode *type_expr, Type *def);
 Entity * check_selector                 (Checker *c, Operand *operand, AstNode *node, Type *type_hint);
 Entity * check_ident                    (Checker *c, Operand *o, AstNode *n, Type *named_type, Type *type_hint, bool allow_import_name);
@@ -259,7 +259,7 @@ bool find_or_generate_polymorphic_procedure(Checker *c, Entity *base_entity, Typ
 
 	// NOTE(bill): This is slightly memory leaking if the type already exists
 	// Maybe it's better to check with the previous types first?
-	Type *final_proc_type = make_type_proc(c->allocator, scope, nullptr, 0, nullptr, 0, false, pt->calling_convention);
+	Type *final_proc_type = alloc_type_proc(scope, nullptr, 0, nullptr, 0, false, pt->calling_convention);
 	bool success = check_procedure_type(c, final_proc_type, pt->node, &operands);
 
 	if (!success) {
@@ -499,7 +499,7 @@ i64 check_distance_between_types(Checker *c, Operand *operand, Type *type) {
 		Type *bfv = base_type(operand->type);
 		i32 bits = bfv->BitFieldValue.bits;
 		i32 size = next_pow2((bits+7)/8);
-		i32 dst_size = cast(i32)type_size_of(c->allocator, type);
+		i32 dst_size = cast(i32)type_size_of(type);
 		i32 diff = gb_abs(dst_size - size);
 		// TODO(bill): figure out a decent rule here
 		return 1;
@@ -1229,7 +1229,7 @@ bool check_representable_as_constant(Checker *c, ExactValue in_value, Type *type
 
 		i64 i = v.value_integer;
 		u64 u = bit_cast<u64>(i);
-		i64 s = 8*type_size_of(c->allocator, type);
+		i64 s = 8*type_size_of(type);
 		u64 umax = ~cast(u64)0ull;
 		if (s < 64) {
 			umax = (1ull << cast(u64)s) - 1ull;
@@ -1397,7 +1397,7 @@ void check_unary_expr(Checker *c, Operand *o, Token op, AstNode *node) {
 			return;
 		}
 		o->mode = Addressing_Value;
-		o->type = make_type_pointer(c->allocator, o->type);
+		o->type = alloc_type_pointer(o->type);
 		return;
 	}
 	}
@@ -1422,7 +1422,7 @@ void check_unary_expr(Checker *c, Operand *o, Token op, AstNode *node) {
 
 		i32 precision = 0;
 		if (is_type_unsigned(type)) {
-			precision = cast(i32)(8 * type_size_of(c->allocator, type));
+			precision = cast(i32)(8 * type_size_of(type));
 		}
 		if (op.kind == Token_Xor && is_type_untyped(type)) {
 			gbString err_str = expr_to_string(node);
@@ -1668,7 +1668,7 @@ Operand check_ptr_addition(Checker *c, TokenKind op, Operand *ptr, Operand *offs
 
 	Type *base_ptr = base_type(ptr->type); GB_ASSERT(base_ptr->kind == Type_Pointer);
 	Type *elem = base_ptr->Pointer.elem;
-	i64 elem_size = type_size_of(c->allocator, elem);
+	i64 elem_size = type_size_of(elem);
 
 	if (elem_size <= 0) {
 		gbString str = type_to_string(elem);
@@ -1902,8 +1902,8 @@ bool check_transmute(Checker *c, AstNode *node, Operand *o, Type *t) {
 		return false;
 	}
 
-	i64 srcz = type_size_of(c->allocator, o->type);
-	i64 dstz = type_size_of(c->allocator, t);
+	i64 srcz = type_size_of(o->type);
+	i64 dstz = type_size_of(t);
 	if (srcz != dstz) {
 		gbString expr_str = expr_to_string(o->expr);
 		gbString type_str = type_to_string(t);
@@ -2082,7 +2082,7 @@ void check_binary_expr(Checker *c, Operand *x, AstNode *node) {
 		if (is_type_pointer(type)) {
 			GB_ASSERT(op.kind == Token_Sub);
 			i64 bytes = a.value_pointer - b.value_pointer;
-			i64 diff = bytes/type_size_of(c->allocator, type);
+			i64 diff = bytes/type_size_of(type);
 			x->value = exact_value_pointer(diff);
 			return;
 		}
@@ -2628,7 +2628,7 @@ Entity *check_selector(Checker *c, Operand *operand, AstNode *node, Type *type_h
 
 	if (entity == nullptr && selector->kind == AstNode_Ident) {
 		String field_name = selector->Ident.token.string;
-		sel = lookup_field(c->allocator, operand->type, field_name, operand->mode == Addressing_Type);
+		sel = lookup_field(operand->type, field_name, operand->mode == Addressing_Type);
 		entity = sel.entity;
 
 		// NOTE(bill): Add type info needed for fields like 'names'
@@ -2672,7 +2672,7 @@ Entity *check_selector(Checker *c, Operand *operand, AstNode *node, Type *type_h
 				return nullptr;
 			}
 
-			sel = lookup_field_from_index(heap_allocator(), type, index);
+			sel = lookup_field_from_index(type, index);
 			entity = sel.entity;
 
 			GB_ASSERT(entity != nullptr);
@@ -2929,7 +2929,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 			return false;
 		}
 		operand->mode = Addressing_Value;
-		operand->type = make_type_pointer(c->allocator, type);
+		operand->type = alloc_type_pointer(type);
 
 		break;
 	}
@@ -2970,7 +2970,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		}
 
 		operand->mode = Addressing_Value;
-		operand->type = make_type_slice(c->allocator, type);
+		operand->type = alloc_type_slice(type);
 
 		break;
 	}
@@ -3147,14 +3147,14 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		} else {
 			elem = type->Slice.elem;
 		}
-		Type *slice_elem = make_type_slice(c->allocator, elem);
+		Type *slice_elem = alloc_type_slice(elem);
 
-		Type *proc_type_params = make_type_tuple(c->allocator);
+		Type *proc_type_params = alloc_type_tuple(c->allocator);
 		proc_type_params->Tuple.variables = gb_alloc_array(c->allocator, Entity *, 2);
 		proc_type_params->Tuple.variable_count = 2;
 		proc_type_params->Tuple.variables[0] = make_entity_param(c->allocator, nullptr, blank_token, operand->type, false, false);
 		proc_type_params->Tuple.variables[1] = make_entity_param(c->allocator, nullptr, blank_token, slice_elem, false, false);
-		Type *proc_type = make_type_proc(c->allocator, nullptr, proc_type_params, 2, nullptr, false, true, ProcCC_Odin);
+		Type *proc_type = alloc_type_proc(nullptr, proc_type_params, 2, nullptr, false, true, ProcCC_Odin);
 
 		check_call_arguments(c, &prev_operand, proc_type, call);
 
@@ -3218,7 +3218,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		t = default_type(t);
 
 		operand->mode = Addressing_Constant;
-		operand->value = exact_value_i64(type_size_of(c->allocator, t));
+		operand->value = exact_value_i64(type_size_of(t));
 		operand->type = t_untyped_integer;
 
 		break;
@@ -3239,7 +3239,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		t = default_type(t);
 
 		operand->mode = Addressing_Constant;
-		operand->value = exact_value_i64(type_align_of(c->allocator, t));
+		operand->value = exact_value_i64(type_align_of(t));
 		operand->type = t_untyped_integer;
 
 		break;
@@ -3269,7 +3269,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 
 
 		ast_node(arg, Ident, field_arg);
-		Selection sel = lookup_field(c->allocator, type, arg->token.string, operand->mode == Addressing_Type);
+		Selection sel = lookup_field(type, arg->token.string, operand->mode == Addressing_Type);
 		if (sel.entity == nullptr) {
 			gbString type_str = type_to_string(bt);
 			error(ce->args[0],
@@ -3286,7 +3286,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		}
 
 		operand->mode = Addressing_Constant;
-		operand->value = exact_value_i64(type_offset_of_from_selection(c->allocator, type, sel));
+		operand->value = exact_value_i64(type_offset_of_from_selection(type, sel));
 		operand->type  = t_uintptr;
 
 		break;
@@ -3408,7 +3408,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		}
 
 		if (arg_count < max_count) {
-			operand->type = make_type_array(c->allocator, elem_type, arg_count);
+			operand->type = alloc_type_array(elem_type, arg_count);
 		}
 		operand->mode = Addressing_Value;
 
@@ -3586,7 +3586,7 @@ break;
 				// No need quit
 			}
 		}
-		operand->type = make_type_slice(c->allocator, ptr_type->Pointer.elem);
+		operand->type = alloc_type_slice(ptr_type->Pointer.elem);
 		operand->mode = Addressing_Value;
 
 		break;
@@ -3619,7 +3619,7 @@ break;
 		}
 		gbAllocator a = c->allocator;
 
-		Type *tuple = make_type_tuple(a);
+		Type *tuple = alloc_type_tuple();
 		isize variable_count = type->Struct.fields.count;
 		array_init(&tuple->Tuple.variables, a, variable_count);
 		// TODO(bill): Should I copy each of the entities or is this good enough?
@@ -3933,8 +3933,8 @@ break;
 			return false;
 		}
 
-		i64 srcz = type_size_of(c->allocator, o->type);
-		i64 dstz = type_size_of(c->allocator, t);
+		i64 srcz = type_size_of(o->type);
+		i64 dstz = type_size_of(t);
 		if (srcz != dstz) {
 			gbString expr_str = expr_to_string(o->expr);
 			gbString type_str = type_to_string(t);
@@ -4005,7 +4005,7 @@ void check_unpack_arguments(Checker *c, Entity **lhs, isize lhs_count, Array<Ope
 		if (o.type == nullptr || o.type->kind != Type_Tuple) {
 			if (allow_ok && lhs_count == 2 && rhs.count == 1 &&
 			    (o.mode == Addressing_MapIndex || o.mode == Addressing_OptionalOk)) {
-				Type *tuple = make_optional_ok_type(c->allocator, o.type);
+				Type *tuple = make_optional_ok_type(o.type);
 				add_type_and_value(&c->info, o.expr, o.mode, tuple, o.value);
 
 				Operand val = o;
@@ -4797,9 +4797,9 @@ CallArgumentError check_polymorphic_struct_type(Checker *c, Operand *operand, As
 
 		String generated_name = make_string_c(expr_to_string(call));
 
-		Type *named_type = make_type_named(a, generated_name, nullptr, nullptr);
+		Type *named_type = alloc_type_named(generated_name, nullptr, nullptr);
 		AstNode *node = clone_ast_node(a, st->node);
-		Type *struct_type = make_type_struct(a);
+		Type *struct_type = alloc_type_struct();
 		struct_type->Struct.node = node;
 		struct_type->Struct.polymorphic_parent = original_type;
 		set_base_type(named_type, struct_type);
@@ -5198,7 +5198,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 	case_ast_node(pl, ProcLit, node);
 		CheckerContext prev_context = c->context;
 		DeclInfo *decl = nullptr;
-		Type *type = alloc_type(c->allocator, Type_Proc);
+		Type *type = alloc_type(Type_Proc);
 		check_open_scope(c, pl->type);
 		{
 			decl = make_declaration_info(c->allocator, c->context.scope, c->context.decl);
@@ -5324,7 +5324,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 				AstNode *count = cl->type->ArrayType.count;
 				if (count->kind == AstNode_UnaryExpr &&
 				    count->UnaryExpr.op.kind == Token_Question) {
-					type = make_type_array(c->allocator, check_type(c, cl->type->ArrayType.elem), -1);
+					type = alloc_type_array(check_type(c, cl->type->ArrayType.elem), -1);
 					is_to_be_determined_array_count = true;
 				}
 			}
@@ -5403,7 +5403,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 						}
 						String name = fv->field->Ident.token.string;
 
-						Selection sel = lookup_field(c->allocator, type, name, o->mode == Addressing_Type);
+						Selection sel = lookup_field(type, name, o->mode == Addressing_Type);
 						bool is_unknown = sel.entity == nullptr;
 						if (is_unknown) {
 							error(elem, "Unknown field '%.*s' in structure literal", LIT(name));
@@ -5583,7 +5583,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 						}
 						String name = fv->field->Ident.token.string;
 
-						Selection sel = lookup_field(c->allocator, type, name, o->mode == Addressing_Type);
+						Selection sel = lookup_field(type, name, o->mode == Addressing_Type);
 						if (sel.entity == nullptr) {
 							error(elem, "Unknown field '%.*s' in 'any' literal", LIT(name));
 							continue;
@@ -5950,7 +5950,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 				o->expr = node;
 				return kind;
 			}
-			o->type = make_type_slice(c->allocator, t->Array.elem);
+			o->type = alloc_type_slice(t->Array.elem);
 			break;
 
 		case Type_Slice:
@@ -5960,7 +5960,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 
 		case Type_DynamicArray:
 			valid = true;
-			o->type = make_type_slice(c->allocator, t->DynamicArray.elem);
+			o->type = alloc_type_slice(t->DynamicArray.elem);
 			break;
 		}
 

src/check_stmt.cpp

@@ -987,7 +987,7 @@ void check_type_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) {
 		    !is_type_any(type_deref(x.type)) &&
 		    cc->list.count == 1 &&
 		    case_type != nullptr) {
-			case_type = make_type_pointer(c->allocator, case_type);
+			case_type = alloc_type_pointer(case_type);
 		}
 
 		if (cc->list.count > 1) {

src/check_type.cpp

@@ -401,7 +401,7 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node, Array<Opera
 						// 	specialization = nullptr;
 						// }
 					}
-					type = make_type_generic(c->allocator, c->context.scope, 0, str_lit(""), specialization);
+					type = alloc_type_generic(c->context.scope, 0, str_lit(""), specialization);
 				} else {
 					type = check_type(c, type_expr);
 					if (is_type_polymorphic(type)) {
@@ -476,7 +476,7 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node, Array<Opera
 			}
 
 			if (entities.count > 0) {
-				Type *tuple = make_type_tuple(c->allocator);
+				Type *tuple = alloc_type_tuple();
 				tuple->Tuple.variables = entities;
 				polymorphic_params = tuple;
 			}
@@ -788,7 +788,7 @@ void check_bit_field_type(Checker *c, Type *bit_field_type, AstNode *node) {
 		}
 		u32 bits = cast(u32)bits_;
 
-		Type *value_type = make_type_bit_field_value(c->allocator, bits);
+		Type *value_type = alloc_type_bit_field_value(bits);
 		Entity *e = make_entity_variable(c->allocator, bit_field_type->BitField.scope, ident->Ident.token, value_type, false);
 		e->identifier = ident;
 		e->flags |= EntityFlag_BitFieldValue;
@@ -1039,7 +1039,7 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari
 					detemine_type_from_operand = true;
 					type = t_invalid;
 				} else {
-					type = make_type_generic(c->allocator, c->context.scope, 0, str_lit(""), specialization);
+					type = alloc_type_generic(c->context.scope, 0, str_lit(""), specialization);
 				}
 			} else {
 				bool prev = c->context.allow_polymorphic_types;
@@ -1232,7 +1232,7 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari
 		// NOTE(bill): Change last variadic parameter to be a slice
 		// Custom Calling convention for variadic parameters
 		Entity *end = variables[variadic_index];
-		end->type = make_type_slice(c->allocator, end->type);
+		end->type = alloc_type_slice(end->type);
 		end->flags |= EntityFlag_Ellipsis;
 		if (is_c_vararg) {
 			end->flags |= EntityFlag_CVarArg;
@@ -1253,7 +1253,7 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari
 		}
 	}
 
-	Type *tuple = make_type_tuple(c->allocator);
+	Type *tuple = alloc_type_tuple();
 	tuple->Tuple.variables = variables;
 
 	if (success_) *success_ = success;
@@ -1274,7 +1274,7 @@ Type *check_get_results(Checker *c, Scope *scope, AstNode *_results) {
 	if (results.count == 0) {
 		return nullptr;
 	}
-	Type *tuple = make_type_tuple(c->allocator);
+	Type *tuple = alloc_type_tuple();
 
 	isize variable_count = 0;
 	for_array(i, results) {
@@ -1413,7 +1413,7 @@ Type *type_to_abi_compat_param_type(gbAllocator a, Type *original_type) {
 			i64 sz = bt->Basic.size;
 			// if (sz > 8 && build_context.word_size < 8) {
 			if (sz > 8) {
-				new_type = make_type_pointer(a, original_type);
+				new_type = alloc_type_pointer(original_type);
 			}
 			break;
 		}
@@ -1429,15 +1429,15 @@ Type *type_to_abi_compat_param_type(gbAllocator a, Type *original_type) {
 		// Could be in C too
 		case Type_Struct:
 		{
-			i64 align = type_align_of(a, original_type);
-			i64 size  = type_size_of(a, original_type);
+			i64 align = type_align_of(original_type);
+			i64 size  = type_size_of(original_type);
 			switch (8*size) {
 			case 8:  new_type = t_u8;  break;
 			case 16: new_type = t_u16; break;
 			case 32: new_type = t_u32; break;
 			case 64: new_type = t_u64; break;
 			default:
-				new_type = make_type_pointer(a, original_type);
+				new_type = alloc_type_pointer(original_type);
 				break;
 			}
 
@@ -1454,7 +1454,7 @@ Type *type_to_abi_compat_param_type(gbAllocator a, Type *original_type) {
 			i64 sz = bt->Basic.size;
 			// if (sz > 8 && build_context.word_size < 8) {
 			if (sz > 8) {
-				new_type = make_type_pointer(a, original_type);
+				new_type = alloc_type_pointer(original_type);
 			}
 
 			break;
@@ -1470,10 +1470,10 @@ Type *type_to_abi_compat_param_type(gbAllocator a, Type *original_type) {
 		case Type_Union:
 		// Could be in C too
 		case Type_Struct: {
-			i64 align = type_align_of(a, original_type);
-			i64 size  = type_size_of(a, original_type);
+			i64 align = type_align_of(original_type);
+			i64 size  = type_size_of(original_type);
 			if (8*size > 16) {
-				new_type = make_type_pointer(a, original_type);
+				new_type = alloc_type_pointer(original_type);
 			}
 
 			break;
@@ -1518,8 +1518,8 @@ Type *type_to_abi_compat_result_type(gbAllocator a, Type *original_type) {
 
 
 		default: {
-			i64 align = type_align_of(a, original_type);
-			i64 size  = type_size_of(a, original_type);
+			i64 align = type_align_of(original_type);
+			i64 size  = type_size_of(original_type);
 			switch (8*size) {
 #if 1
 			case 8:  new_type = t_u8;  break;
@@ -1540,7 +1540,7 @@ Type *type_to_abi_compat_result_type(gbAllocator a, Type *original_type) {
 	}
 
 	if (new_type != original_type) {
-		Type *tuple = make_type_tuple(a);
+		Type *tuple = alloc_type_tuple();
 		auto variables = array_make<Entity *>(a, 0, 1);
 		array_add(&variables, make_entity_param(a, original_type->Tuple.variables[0]->scope, empty_token, new_type, false, false));
 		tuple->Tuple.variables = variables;
@@ -1564,7 +1564,7 @@ bool abi_compat_return_by_value(gbAllocator a, ProcCallingConvention cc, Type *a
 
 
 	if (build_context.ODIN_OS == "windows") {
-		i64 size = 8*type_size_of(a, abi_return_type);
+		i64 size = 8*type_size_of(abi_return_type);
 		switch (size) {
 		case 0:
 		case 8:
@@ -1727,23 +1727,24 @@ i64 check_array_count(Checker *c, Operand *o, AstNode *e) {
 	return 0;
 }
 
-Type *make_optional_ok_type(gbAllocator a, Type *value) {
+Type *make_optional_ok_type(Type *value) {
+	gbAllocator a = heap_allocator();
 	bool typed = true;
-	Type *t = make_type_tuple(a);
+	Type *t = alloc_type_tuple();
 	array_init(&t->Tuple.variables, a, 0, 2);
 	array_add (&t->Tuple.variables, make_entity_field(a, nullptr, blank_token, value,  false, 0));
 	array_add (&t->Tuple.variables, make_entity_field(a, nullptr, blank_token, typed ? t_bool : t_untyped_bool, false, 1));
 	return t;
 }
 
-void generate_map_entry_type(gbAllocator a, Type *type) {
+void init_map_entry_type(Type *type) {
 	GB_ASSERT(type->kind == Type_Map);
 	if (type->Map.entry_type != nullptr) return;
 
 	// NOTE(bill): The preload types may have not been set yet
 	GB_ASSERT(t_map_key != nullptr);
-
-	Type *entry_type = make_type_struct(a);
+	gbAllocator a = heap_allocator();
+	Type *entry_type = alloc_type_struct();
 
 	/*
 	struct {
@@ -1769,9 +1770,9 @@ void generate_map_entry_type(gbAllocator a, Type *type) {
 	type->Map.entry_type = entry_type;
 }
 
-void generate_map_internal_types(gbAllocator a, Type *type) {
+void init_map_internal_types(Type *type) {
 	GB_ASSERT(type->kind == Type_Map);
-	generate_map_entry_type(a, type);
+	init_map_entry_type(type);
 	if (type->Map.internal_type != nullptr) return;
 	if (type->Map.generated_struct_type != nullptr) return;
 
@@ -1780,7 +1781,7 @@ void generate_map_internal_types(gbAllocator a, Type *type) {
 	GB_ASSERT(key != nullptr);
 	GB_ASSERT(value != nullptr);
 
-	Type *generated_struct_type = make_type_struct(a);
+	Type *generated_struct_type = alloc_type_struct();
 
 	/*
 	struct {
@@ -1788,12 +1789,13 @@ void generate_map_internal_types(gbAllocator a, Type *type) {
 		entries: [dynamic]EntryType;
 	}
 	*/
+	gbAllocator a = heap_allocator();
 	AstNode *dummy_node = gb_alloc_item(a, AstNode);
 	dummy_node->kind = AstNode_Invalid;
 	Scope *s = create_scope(universal_scope, a);
 
-	Type *hashes_type  = make_type_dynamic_array(a, t_int);
-	Type *entries_type = make_type_dynamic_array(a, type->Map.entry_type);
+	Type *hashes_type  = alloc_type_dynamic_array(t_int);
+	Type *entries_type = alloc_type_dynamic_array(type->Map.entry_type);
 
 
 	auto fields = array_make<Entity *>(a, 0, 2);
@@ -1802,10 +1804,10 @@ void generate_map_internal_types(gbAllocator a, Type *type) {
 
 	generated_struct_type->Struct.fields = fields;
 
-	type_set_offsets(a, generated_struct_type);
+	type_set_offsets(generated_struct_type);
 	type->Map.generated_struct_type = generated_struct_type;
 	type->Map.internal_type         = generated_struct_type;
-	type->Map.lookup_result_type    = make_optional_ok_type(a, value);
+	type->Map.lookup_result_type    = make_optional_ok_type(value);
 }
 
 void check_map_type(Checker *c, Type *type, AstNode *node) {
@@ -1830,7 +1832,7 @@ void check_map_type(Checker *c, Type *type, AstNode *node) {
 
 
 	init_preload(c);
-	generate_map_internal_types(c->allocator, type);
+	init_map_internal_types(type);
 
 	// error(node, "'map' types are not yet implemented");
 }
@@ -1916,7 +1918,7 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type)
 			// 	specific = nullptr;
 			// }
 		}
-		Type *t = make_type_generic(c->allocator, c->context.scope, 0, token.string, specific);
+		Type *t = alloc_type_generic(c->context.scope, 0, token.string, specific);
 		if (c->context.allow_polymorphic_types) {
 			Scope *ps = c->context.polymorphic_scope;
 			Scope *s = c->context.scope;
@@ -1974,14 +1976,14 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type)
 	case_ast_node(ue, UnaryExpr, e);
 		switch (ue->op.kind) {
 		case Token_Pointer:
-			*type = make_type_pointer(c->allocator, check_type(c, ue->expr));
+			*type = alloc_type_pointer(check_type(c, ue->expr));
 			set_base_type(named_type, *type);
 			return true;
 		}
 	case_end;
 
 	case_ast_node(pt, PointerType, e);
-		*type = make_type_pointer(c->allocator, check_type(c, pt->type));
+		*type = alloc_type_pointer(check_type(c, pt->type));
 		set_base_type(named_type, *type);
 		return true;
 	case_end;
@@ -1999,10 +2001,10 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type)
 				count = 0;
 			}
 			Type *elem = check_type(c, at->elem, nullptr);
-			*type = make_type_array(c->allocator, elem, count, generic_type);
+			*type = alloc_type_array(elem, count, generic_type);
 		} else {
 			Type *elem = check_type(c, at->elem);
-			*type = make_type_slice(c->allocator, elem);
+			*type = alloc_type_slice(elem);
 		}
 		set_base_type(named_type, *type);
 		return true;
@@ -2010,7 +2012,7 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type)
 
 	case_ast_node(dat, DynamicArrayType, e);
 		Type *elem = check_type(c, dat->elem);
-		*type = make_type_dynamic_array(c->allocator, elem);
+		*type = alloc_type_dynamic_array(elem);
 		set_base_type(named_type, *type);
 		return true;
 	case_end;
@@ -2020,7 +2022,7 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type)
 		c->context.in_polymorphic_specialization = false;
 		c->context.type_level += 1;
 
-		*type = make_type_struct(c->allocator);
+		*type = alloc_type_struct();
 		set_base_type(named_type, *type);
 		check_open_scope(c, e);
 		check_struct_type(c, *type, e, nullptr, named_type);
@@ -2034,7 +2036,7 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type)
 		c->context.in_polymorphic_specialization = false;
 		c->context.type_level += 1;
 
-		*type = make_type_union(c->allocator);
+		*type = alloc_type_union();
 		set_base_type(named_type, *type);
 		check_open_scope(c, e);
 		check_union_type(c, *type, e);
@@ -2048,7 +2050,7 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type)
 		defer (c->context.in_polymorphic_specialization = ips);
 		c->context.in_polymorphic_specialization = false;
 
-		*type = make_type_enum(c->allocator);
+		*type = alloc_type_enum();
 		set_base_type(named_type, *type);
 		check_open_scope(c, e);
 		check_enum_type(c, *type, named_type, e);
@@ -2058,7 +2060,7 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type)
 	case_end;
 
 	case_ast_node(et, BitFieldType, e);
-		*type = make_type_bit_field(c->allocator);
+		*type = alloc_type_bit_field();
 		set_base_type(named_type, *type);
 		check_open_scope(c, e);
 		check_bit_field_type(c, *type, e);
@@ -2071,7 +2073,7 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type)
 		defer (c->context.in_polymorphic_specialization = ips);
 		c->context.in_polymorphic_specialization = false;
 
-		*type = alloc_type(c->allocator, Type_Proc);
+		*type = alloc_type(Type_Proc);
 		set_base_type(named_type, *type);
 		check_open_scope(c, e);
 		check_procedure_type(c, *type, e);
@@ -2084,7 +2086,7 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type)
 		defer (c->context.in_polymorphic_specialization = ips);
 		c->context.in_polymorphic_specialization = false;
 
-		*type = alloc_type(c->allocator, Type_Map);
+		*type = alloc_type(Type_Map);
 		set_base_type(named_type, *type);
 		check_map_type(c, *type, e);
 		return true;

src/checker.cpp

@@ -568,12 +568,12 @@ void init_universal_scope(void) {
 	}
 
 
-	t_u8_ptr       = make_type_pointer(a, t_u8);
-	t_int_ptr      = make_type_pointer(a, t_int);
-	t_i64_ptr      = make_type_pointer(a, t_i64);
-	t_f64_ptr      = make_type_pointer(a, t_f64);
-	t_u8_slice     = make_type_slice(a, t_u8);
-	t_string_slice = make_type_slice(a, t_string);
+	t_u8_ptr       = alloc_type_pointer(t_u8);
+	t_int_ptr      = alloc_type_pointer(t_int);
+	t_i64_ptr      = alloc_type_pointer(t_i64);
+	t_f64_ptr      = alloc_type_pointer(t_f64);
+	t_u8_slice     = alloc_type_slice(t_u8);
+	t_string_slice = alloc_type_slice(t_string);
 }
 
 
@@ -1015,18 +1015,18 @@ void add_type_info_type(Checker *c, Type *t) {
 
 	case Type_Array:
 		add_type_info_type(c, bt->Array.elem);
-		add_type_info_type(c, make_type_pointer(c->allocator, bt->Array.elem));
+		add_type_info_type(c, alloc_type_pointer(bt->Array.elem));
 		add_type_info_type(c, t_int);
 		break;
 	case Type_DynamicArray:
 		add_type_info_type(c, bt->DynamicArray.elem);
-		add_type_info_type(c, make_type_pointer(c->allocator, bt->DynamicArray.elem));
+		add_type_info_type(c, alloc_type_pointer(bt->DynamicArray.elem));
 		add_type_info_type(c, t_int);
 		add_type_info_type(c, t_allocator);
 		break;
 	case Type_Slice:
 		add_type_info_type(c, bt->Slice.elem);
-		add_type_info_type(c, make_type_pointer(c->allocator, bt->Slice.elem));
+		add_type_info_type(c, alloc_type_pointer(bt->Slice.elem));
 		add_type_info_type(c, t_int);
 		break;
 
@@ -1056,7 +1056,7 @@ void add_type_info_type(Checker *c, Type *t) {
 		break;
 
 	case Type_Map:
-		generate_map_internal_types(c->allocator, bt);
+		init_map_internal_types(bt);
 		add_type_info_type(c, bt->Map.key);
 		add_type_info_type(c, bt->Map.value);
 		add_type_info_type(c, bt->Map.generated_struct_type);
@@ -1332,14 +1332,14 @@ void init_preload(Checker *c) {
 		Entity *type_info_entity = find_core_entity(c, str_lit("Type_Info"));
 
 		t_type_info = type_info_entity->type;
-		t_type_info_ptr = make_type_pointer(c->allocator, t_type_info);
+		t_type_info_ptr = alloc_type_pointer(t_type_info);
 		GB_ASSERT(is_type_struct(type_info_entity->type));
 		TypeStruct *tis = &base_type(type_info_entity->type)->Struct;
 
 		Entity *type_info_enum_value = find_core_entity(c, str_lit("Type_Info_Enum_Value"));
 
 		t_type_info_enum_value = type_info_enum_value->type;
-		t_type_info_enum_value_ptr = make_type_pointer(c->allocator, t_type_info_enum_value);
+		t_type_info_enum_value_ptr = alloc_type_pointer(t_type_info_enum_value);
 
 		GB_ASSERT(tis->fields.count == 3);
 
@@ -1367,44 +1367,44 @@ void init_preload(Checker *c) {
 		t_type_info_map           = find_core_type(c, str_lit("Type_Info_Map"));
 		t_type_info_bit_field     = find_core_type(c, str_lit("Type_Info_Bit_Field"));
 
-		t_type_info_named_ptr         = make_type_pointer(c->allocator, t_type_info_named);
-		t_type_info_integer_ptr       = make_type_pointer(c->allocator, t_type_info_integer);
-		t_type_info_rune_ptr          = make_type_pointer(c->allocator, t_type_info_rune);
-		t_type_info_float_ptr         = make_type_pointer(c->allocator, t_type_info_float);
-		t_type_info_complex_ptr       = make_type_pointer(c->allocator, t_type_info_complex);
-		t_type_info_string_ptr        = make_type_pointer(c->allocator, t_type_info_string);
-		t_type_info_boolean_ptr       = make_type_pointer(c->allocator, t_type_info_boolean);
-		t_type_info_any_ptr           = make_type_pointer(c->allocator, t_type_info_any);
-		t_type_info_pointer_ptr       = make_type_pointer(c->allocator, t_type_info_pointer);
-		t_type_info_procedure_ptr     = make_type_pointer(c->allocator, t_type_info_procedure);
-		t_type_info_array_ptr         = make_type_pointer(c->allocator, t_type_info_array);
-		t_type_info_dynamic_array_ptr = make_type_pointer(c->allocator, t_type_info_dynamic_array);
-		t_type_info_slice_ptr         = make_type_pointer(c->allocator, t_type_info_slice);
-		t_type_info_tuple_ptr         = make_type_pointer(c->allocator, t_type_info_tuple);
-		t_type_info_struct_ptr        = make_type_pointer(c->allocator, t_type_info_struct);
-		t_type_info_union_ptr         = make_type_pointer(c->allocator, t_type_info_union);
-		t_type_info_enum_ptr          = make_type_pointer(c->allocator, t_type_info_enum);
-		t_type_info_map_ptr           = make_type_pointer(c->allocator, t_type_info_map);
-		t_type_info_bit_field_ptr     = make_type_pointer(c->allocator, t_type_info_bit_field);
+		t_type_info_named_ptr         = alloc_type_pointer(t_type_info_named);
+		t_type_info_integer_ptr       = alloc_type_pointer(t_type_info_integer);
+		t_type_info_rune_ptr          = alloc_type_pointer(t_type_info_rune);
+		t_type_info_float_ptr         = alloc_type_pointer(t_type_info_float);
+		t_type_info_complex_ptr       = alloc_type_pointer(t_type_info_complex);
+		t_type_info_string_ptr        = alloc_type_pointer(t_type_info_string);
+		t_type_info_boolean_ptr       = alloc_type_pointer(t_type_info_boolean);
+		t_type_info_any_ptr           = alloc_type_pointer(t_type_info_any);
+		t_type_info_pointer_ptr       = alloc_type_pointer(t_type_info_pointer);
+		t_type_info_procedure_ptr     = alloc_type_pointer(t_type_info_procedure);
+		t_type_info_array_ptr         = alloc_type_pointer(t_type_info_array);
+		t_type_info_dynamic_array_ptr = alloc_type_pointer(t_type_info_dynamic_array);
+		t_type_info_slice_ptr         = alloc_type_pointer(t_type_info_slice);
+		t_type_info_tuple_ptr         = alloc_type_pointer(t_type_info_tuple);
+		t_type_info_struct_ptr        = alloc_type_pointer(t_type_info_struct);
+		t_type_info_union_ptr         = alloc_type_pointer(t_type_info_union);
+		t_type_info_enum_ptr          = alloc_type_pointer(t_type_info_enum);
+		t_type_info_map_ptr           = alloc_type_pointer(t_type_info_map);
+		t_type_info_bit_field_ptr     = alloc_type_pointer(t_type_info_bit_field);
 	}
 
 	if (t_allocator == nullptr) {
 		Entity *e = find_core_entity(c, str_lit("Allocator"));
 		t_allocator = e->type;
-		t_allocator_ptr = make_type_pointer(c->allocator, t_allocator);
+		t_allocator_ptr = alloc_type_pointer(t_allocator);
 	}
 
 	if (t_context == nullptr) {
 		Entity *e = find_core_entity(c, str_lit("Context"));
 		e_context = e;
 		t_context = e->type;
-		t_context_ptr = make_type_pointer(c->allocator, t_context);
+		t_context_ptr = alloc_type_pointer(t_context);
 	}
 
 	if (t_source_code_location == nullptr) {
 		Entity *e = find_core_entity(c, str_lit("Source_Code_Location"));
 		t_source_code_location = e->type;
-		t_source_code_location_ptr = make_type_pointer(c->allocator, t_allocator);
+		t_source_code_location_ptr = alloc_type_pointer(t_allocator);
 	}
 
 	if (t_map_key == nullptr) {
@@ -3125,7 +3125,7 @@ void check_parsed_files(Checker *c) {
 		Entity *e = c->info.definitions[i];
 		if (e->kind == Entity_TypeName && e->type != nullptr) {
 			// i64 size  = type_size_of(c->allocator, e->type);
-			i64 align = type_align_of(c->allocator, e->type);
+			i64 align = type_align_of(e->type);
 			if (align > 0 && ptr_set_exists(&c->info.minimum_dependency_set, e)) {
 				add_type_info_type(c, e->type);
 			}

src/ir.cpp

@@ -826,7 +826,7 @@ irValue *ir_value_type_name(gbAllocator a, String name, Type *type) {
 irValue *ir_value_global(gbAllocator a, Entity *e, irValue *value) {
 	irValue *v = ir_alloc_value(a, irValue_Global);
 	v->Global.entity = e;
-	v->Global.type = make_type_pointer(a, e->type);
+	v->Global.type = alloc_type_pointer(e->type);
 	v->Global.value = value;
 	array_init(&v->Global.referrers, heap_allocator()); // TODO(bill): Replace heap allocator here
 	return v;
@@ -902,11 +902,11 @@ irValue *ir_instr_local(irProcedure *p, Entity *e, bool zero_initialized) {
 	irValue *v = ir_alloc_instr(p, irInstr_Local);
 	irInstr *i = &v->Instr;
 	i->Local.entity = e;
-	i->Local.type = make_type_pointer(p->module->allocator, e->type);
+	i->Local.type = alloc_type_pointer(e->type);
 	i->Local.zero_initialized = zero_initialized;
 	// i->Local.alignment = type_align_of(p->module->allocator, e->type);
 	// TODO(bill): determine the correct alignment
-	i->Local.alignment = gb_max(16, type_align_of(p->module->allocator, e->type));
+	i->Local.alignment = gb_max(16, type_align_of(e->type));
 	array_init(&i->Local.referrers, heap_allocator()); // TODO(bill): Replace heap allocator here
 	ir_module_add_value(p->module, e, v);
 	return v;
@@ -944,7 +944,7 @@ irValue *ir_instr_array_element_ptr(irProcedure *p, irValue *address, irValue *e
 	t = base_type(type_deref(t));
 	GB_ASSERT(is_type_array(t));
 
-	Type *result_type = make_type_pointer(p->module->allocator, t->Array.elem);
+	Type *result_type = alloc_type_pointer(t->Array.elem);
 
 	i->ArrayElementPtr.address = address;
 	i->ArrayElementPtr.elem_index = elem_index;
@@ -994,9 +994,9 @@ irValue *ir_instr_union_tag_ptr(irProcedure *p, irValue *address) {
 	irValue *v = ir_alloc_instr(p, irInstr_UnionTagPtr);
 	irInstr *i = &v->Instr;
 	i->UnionTagPtr.address = address;
-	// i->UnionTagPtr.type = make_type_pointer(p->module->allocator, t_type_info_ptr);
+	// i->UnionTagPtr.type = alloc_type_pointer(t_type_info_ptr);
 	Type *u = type_deref(ir_type(address));
-	i->UnionTagPtr.type = make_type_pointer(p->module->allocator, union_tag_type(p->module->allocator, u));
+	i->UnionTagPtr.type = alloc_type_pointer(union_tag_type(u));
 	return v;
 }
 
@@ -1007,7 +1007,7 @@ irValue *ir_instr_union_tag_value(irProcedure *p, irValue *address) {
 	// i->UnionTagValue.type = t_type_info_ptr;
 	// i->UnionTagValue.type = t_int;
 	Type *u = type_deref(ir_type(address));
-	i->UnionTagPtr.type = union_tag_type(p->module->allocator, u);
+	i->UnionTagPtr.type = union_tag_type(u);
 	return v;
 }
 
@@ -1208,7 +1208,7 @@ irValue *ir_generate_array(irModule *m, Type *elem_type, i64 count, String prefi
 
 	Entity *e = make_entity_variable(a, nullptr,
 	                                 make_token_ident(s),
-	                                 make_type_array(a, elem_type, count),
+	                                 alloc_type_array(elem_type, count),
 	                                 false);
 	irValue *value = ir_value_global(a, e, nullptr);
 	value->Global.is_private = true;
@@ -1297,7 +1297,7 @@ irValue *ir_add_module_constant(irModule *m, Type *type, ExactValue value) {
 			return ir_value_nil(a, type);
 		}
 		Type *elem = base_type(type)->Slice.elem;
-		Type *t = make_type_array(a, elem, count);
+		Type *t = alloc_type_array(elem, count);
 		irValue *backing_array = ir_add_module_constant(m, t, value);
 
 
@@ -1333,7 +1333,7 @@ irValue *ir_add_global_string_array(irModule *m, String string) {
 	String name = make_string(str, len-1);
 	Token token = {Token_String};
 	token.string = name;
-	Type *type = make_type_array(a, t_u8, string.len+1);
+	Type *type = alloc_type_array(t_u8, string.len+1);
 	ExactValue ev = exact_value_string(string);
 	Entity *entity = make_entity_constant(a, nullptr, token, type, ev);
 	irValue *g = ir_value_global(a, entity, ir_add_module_constant(m, type, ev));
@@ -1482,7 +1482,7 @@ irValue *ir_add_param(irProcedure *proc, Entity *e, AstNode *expr, Type *abi_typ
 
 	case irParamPass_Integer: {
 		irValue *l = ir_add_local(proc, e, expr, false);
-		irValue *iptr = ir_emit_conv(proc, l, make_type_pointer(proc->module->allocator, p->type));
+		irValue *iptr = ir_emit_conv(proc, l, alloc_type_pointer(p->type));
 		ir_emit_store(proc, iptr, v);
 		return ir_emit_load(proc, l);
 	}
@@ -1600,7 +1600,7 @@ void ir_emit_zero_init(irProcedure *p, irValue *address, AstNode *expr) {
 	Type *t = type_deref(ir_type(address));
 	auto args = array_make<irValue *>(a, 2);
 	args[0] = ir_emit_conv(p, address, t_rawptr);
-	args[1] = ir_const_int(a, type_size_of(a, t));
+	args[1] = ir_const_int(a, type_size_of(t));
 	if (p->entity->token.string != "__mem_zero") {
 		ir_emit_global_call(p, "__mem_zero", args, expr);
 	}
@@ -1625,7 +1625,7 @@ void ir_emit_init_context(irProcedure *proc, irValue *c = nullptr) {
 
 
 irValue *ir_copy_value_to_ptr(irProcedure *proc, irValue *val, Type *new_type, i64 alignment) {
-	i64 type_alignment = type_align_of(proc->module->allocator, new_type);
+	i64 type_alignment = type_align_of(new_type);
 	if (alignment < type_alignment) {
 		alignment = type_alignment;
 	}
@@ -1840,10 +1840,10 @@ irValue *ir_gen_map_header(irProcedure *proc, irValue *map_val_ptr, Type *map_ty
 		ir_emit_store(proc, ir_emit_struct_ep(proc, h, 1), v_true);
 	}
 
-	i64 entry_size   = type_size_of(a, map_type->Map.entry_type);
-	i64 entry_align  = type_align_of(a, map_type->Map.entry_type);
-	i64 value_offset = type_offset_of(a, map_type->Map.entry_type, 2);
-	i64 value_size   = type_size_of(a, map_type->Map.value);
+	i64 entry_size   = type_size_of  (map_type->Map.entry_type);
+	i64 entry_align  = type_align_of (map_type->Map.entry_type);
+	i64 value_offset = type_offset_of(map_type->Map.entry_type, 2);
+	i64 value_size   = type_size_of  (map_type->Map.value);
 
 	ir_emit_store(proc, ir_emit_struct_ep(proc, h, 2), ir_const_int(a, entry_size));
 	ir_emit_store(proc, ir_emit_struct_ep(proc, h, 3), ir_const_int(a, entry_align));
@@ -1866,7 +1866,7 @@ irValue *ir_gen_map_key(irProcedure *proc, irValue *key, Type *key_type) {
 		ir_emit_store(proc, ir_emit_struct_ep(proc, v, 0), ir_emit_conv(proc, p, hash_type));
 	} else if (is_type_float(t)) {
 		irValue *bits = nullptr;
-		i64 size = type_size_of(proc->module->allocator, t);
+		i64 size = type_size_of(t);
 		switch (8*size) {
 		case 32:  bits = ir_emit_transmute(proc, key, t_u32); break;
 		case 64:  bits = ir_emit_transmute(proc, key, t_u64);  break;
@@ -2000,7 +2000,7 @@ irValue *ir_addr_store(irProcedure *proc, irAddr addr, irValue *value) {
 				v = ir_emit_arith(proc, Token_Shl, v, shift_amount, int_type);
 				v = ir_emit_arith(proc, Token_Shr, v, shift_amount, int_type);
 			}
-			irValue *ptr = ir_emit_conv(proc, bytes, make_type_pointer(a, int_type));
+			irValue *ptr = ir_emit_conv(proc, bytes, alloc_type_pointer(int_type));
 			v = ir_emit_arith(proc, Token_Or, ir_emit_load(proc, ptr), v, int_type);
 			return ir_emit_store(proc, ptr, v);
 		}
@@ -2020,7 +2020,7 @@ irValue *ir_addr_store(irProcedure *proc, irAddr addr, irValue *value) {
 		// Remaining bytes
 		{
 			irValue *shift_amount = ir_const_int(a, bit_inset);
-			irValue *ptr = ir_emit_conv(proc, ir_emit_ptr_offset(proc, bytes, v_one), make_type_pointer(a, int_type));
+			irValue *ptr = ir_emit_conv(proc, ir_emit_ptr_offset(proc, bytes, v_one), alloc_type_pointer(int_type));
 			irValue *v = ir_emit_arith(proc, Token_Shr, value, shift_amount, int_type);
 			v = ir_emit_arith(proc, Token_Or, ir_emit_load(proc, ptr), v, int_type);
 			return ir_emit_store(proc, ptr, v);
@@ -2104,7 +2104,7 @@ irValue *ir_addr_load(irProcedure *proc, irAddr addr) {
 		irValue *bytes = ir_emit_conv(proc, addr.addr, t_u8_ptr);
 		bytes = ir_emit_ptr_offset(proc, bytes, ir_const_int(a, byte_index));
 
-		Type *int_ptr = make_type_pointer(a, int_type);
+		Type *int_ptr = alloc_type_pointer(int_type);
 
 		if (bit_inset == 0) {
 			irValue *v = ir_emit_load(proc, ir_emit_conv(proc, bytes, int_ptr));
@@ -2168,7 +2168,7 @@ irValue *ir_map_entries(irProcedure *proc, irValue *value) {
 	gbAllocator a = proc->module->allocator;
 	Type *t = base_type(ir_type(value));
 	GB_ASSERT_MSG(t->kind == Type_Map, "%s", type_to_string(t));
-	generate_map_internal_types(a, t);
+	init_map_internal_types(t);
 	Type *gst = t->Map.generated_struct_type;
 	isize index = 1;
 	irValue *entries = ir_emit(proc, ir_instr_struct_extract_value(proc, value, index, gst->Struct.fields[index]->type));
@@ -2179,10 +2179,10 @@ irValue *ir_map_entries_ptr(irProcedure *proc, irValue *value) {
 	gbAllocator a = proc->module->allocator;
 	Type *t = base_type(type_deref(ir_type(value)));
 	GB_ASSERT_MSG(t->kind == Type_Map, "%s", type_to_string(t));
-	generate_map_internal_types(a, t);
+	init_map_internal_types(t);
 	Type *gst = t->Map.generated_struct_type;
 	isize index = 1;
-	Type *ptr_t = make_type_pointer(a, gst->Struct.fields[index]->type);
+	Type *ptr_t = alloc_type_pointer(gst->Struct.fields[index]->type);
 	irValue *entries = ir_emit(proc, ir_instr_struct_element_ptr(proc, value, index, ptr_t));
 	return entries;
 }
@@ -2348,7 +2348,7 @@ irValue *ir_emit_arith(irProcedure *proc, TokenKind op, irValue *left, irValue *
 			irModule *m = proc->module;
 			Type *ptr_type = base_type(t_left);
 			GB_ASSERT(!is_type_rawptr(ptr_type));
-			irValue *elem_size = ir_const_int(m->allocator, type_size_of(m->allocator, ptr_type->Pointer.elem));
+			irValue *elem_size = ir_const_int(m->allocator, type_size_of(ptr_type->Pointer.elem));
 			irValue *x = ir_emit_conv(proc, ir_emit_conv(proc, left, t_uintptr), type);
 			irValue *y = ir_emit_conv(proc, ir_emit_conv(proc, right, t_uintptr), type);
 			irValue *diff = ir_emit_arith(proc, op, x, y, type);
@@ -2494,8 +2494,8 @@ irValue *ir_emit_comp(irProcedure *proc, TokenKind op_kind, irValue *left, irVal
 		right = ir_emit_conv(proc, right, ir_type(left));
 	} else {
 		gbAllocator a = proc->module->allocator;
-		i64 ls = type_size_of(a, ir_type(left));
-		i64 rs = type_size_of(a, ir_type(right));
+		i64 ls = type_size_of(ir_type(left));
+		i64 rs = type_size_of(ir_type(right));
 		if (ls < rs) {
 			left = ir_emit_conv(proc, left, ir_type(right));
 		} else if (ls > rs) {
@@ -2552,7 +2552,7 @@ irValue *ir_emit_comp(irProcedure *proc, TokenKind op_kind, irValue *left, irVal
 
 	if (is_type_complex(a)) {
 		char *runtime_proc = "";
-		i64 sz = 8*type_size_of(proc->module->allocator, a);
+		i64 sz = 8*type_size_of(a);
 		switch (sz) {
 		case 64:
 			switch (op_kind) {
@@ -2603,52 +2603,52 @@ irValue *ir_emit_struct_ep(irProcedure *proc, irValue *s, i32 index) {
 	Type *result_type = nullptr;
 
 	if (is_type_struct(t)) {
-		result_type = make_type_pointer(a, t->Struct.fields[index]->type);
+		result_type = alloc_type_pointer(t->Struct.fields[index]->type);
 	} else if (is_type_union(t)) {
 		GB_ASSERT(index == -1);
 		return ir_emit_union_tag_ptr(proc, s);
 	} else if (is_type_tuple(t)) {
 		GB_ASSERT(t->Tuple.variables.count > 0);
-		result_type = make_type_pointer(a, t->Tuple.variables[index]->type);
+		result_type = alloc_type_pointer(t->Tuple.variables[index]->type);
 	} else if (is_type_complex(t)) {
 		Type *ft = base_complex_elem_type(t);
 		switch (index) {
-		case 0: result_type = make_type_pointer(a, ft); break;
-		case 1: result_type = make_type_pointer(a, ft); break;
+		case 0: result_type = alloc_type_pointer(ft); break;
+		case 1: result_type = alloc_type_pointer(ft); break;
 		}
 	} else if (is_type_slice(t)) {
 		switch (index) {
-		case 0: result_type = make_type_pointer(a, make_type_pointer(a, t->Slice.elem)); break;
-		case 1: result_type = make_type_pointer(a, t_int); break;
-		case 2: result_type = make_type_pointer(a, t_int); break;
+		case 0: result_type = alloc_type_pointer(alloc_type_pointer(t->Slice.elem)); break;
+		case 1: result_type = alloc_type_pointer(t_int); break;
+		case 2: result_type = alloc_type_pointer(t_int); break;
 		}
 	} else if (is_type_string(t)) {
 		switch (index) {
-		case 0: result_type = make_type_pointer(a, t_u8_ptr); break;
-		case 1: result_type = make_type_pointer(a, t_int);    break;
+		case 0: result_type = alloc_type_pointer(t_u8_ptr); break;
+		case 1: result_type = alloc_type_pointer(t_int);    break;
 		}
 	} else if (is_type_any(t)) {
 		switch (index) {
-		case 0: result_type = make_type_pointer(a, t_rawptr);        break;
-		case 1: result_type = make_type_pointer(a, t_type_info_ptr); break;
+		case 0: result_type = alloc_type_pointer(t_rawptr);        break;
+		case 1: result_type = alloc_type_pointer(t_type_info_ptr); break;
 		}
 	} else if (is_type_dynamic_array(t)) {
 		switch (index) {
-		case 0: result_type = make_type_pointer(a, make_type_pointer(a, t->DynamicArray.elem)); break;
+		case 0: result_type = alloc_type_pointer(alloc_type_pointer(t->DynamicArray.elem)); break;
 		case 1: result_type = t_int_ptr;                                      break;
 		case 2: result_type = t_int_ptr;                                      break;
 		case 3: result_type = t_allocator_ptr;                                break;
 		}
 	} /* else if (is_type_map(t)) {
-		generate_map_internal_types(a, t);
-		Type *itp = make_type_pointer(a, t->Map.internal_type);
+		init_map_internal_types(t);
+		Type *itp = alloc_type_pointer(t->Map.internal_type);
 		s = ir_emit_load(proc, ir_emit_transmute(proc, s, itp));
 
 		Type *gst = t->Map.generated_struct_type;
 		GB_ASSERT(gst->kind == Type_Struct);
 		switch (index) {
-		case 0: result_type = make_type_pointer(a, gst->Struct.fields[0]->type); break;
-		case 1: result_type = make_type_pointer(a, gst->Struct.fields[1]->type); break;
+		case 0: result_type = alloc_type_pointer(gst->Struct.fields[0]->type); break;
+		case 1: result_type = alloc_type_pointer(gst->Struct.fields[1]->type); break;
 		}
 	} */else {
 		GB_PANIC("TODO(bill): struct_gep type: %s, %d", type_to_string(ir_type(s)), index);
@@ -2705,13 +2705,13 @@ irValue *ir_emit_struct_ev(irProcedure *proc, irValue *s, i32 index) {
 		break;
 	case Type_Slice:
 		switch (index) {
-		case 0: result_type = make_type_pointer(a, t->Slice.elem); break;
+		case 0: result_type = alloc_type_pointer(t->Slice.elem); break;
 		case 1: result_type = t_int; break;
 		}
 		break;
 	case Type_DynamicArray:
 		switch (index) {
-		case 0: result_type = make_type_pointer(a, t->DynamicArray.elem); break;
+		case 0: result_type = alloc_type_pointer(t->DynamicArray.elem); break;
 		case 1: result_type = t_int;                                      break;
 		case 2: result_type = t_int;                                      break;
 		case 3: result_type = t_allocator;                                break;
@@ -2719,7 +2719,7 @@ irValue *ir_emit_struct_ev(irProcedure *proc, irValue *s, i32 index) {
 		break;
 
 	// case Type_Map: {
-	// 	generate_map_internal_types(a, t);
+	// 	init_map_internal_types(t);
 	// 	Type *gst = t->Map.generated_struct_type;
 	// 	switch (index) {
 	// 	case 0: result_type = gst->Struct.fields[0]->type; break;
@@ -2755,7 +2755,7 @@ irValue *ir_emit_deep_field_gep(irProcedure *proc, irValue *e, Selection sel) {
 
 		if (is_type_raw_union(type)) {
 			type = type->Struct.fields[index]->type;
-			e = ir_emit_conv(proc, e, make_type_pointer(a, type));
+			e = ir_emit_conv(proc, e, alloc_type_pointer(type));
 		} else if (is_type_struct(type)) {
 			type = type->Struct.fields[index]->type;
 			e = ir_emit_struct_ep(proc, e, index);
@@ -2974,7 +2974,7 @@ irValue *ir_find_or_add_entity_string(irModule *m, String str) {
 
 
 irValue *ir_const_union_tag(gbAllocator a, Type *u, Type *v) {
-	return ir_value_constant(a, union_tag_type(a, u), exact_value_i64(union_variant_index(u, v)));
+	return ir_value_constant(a, union_tag_type(u), exact_value_i64(union_variant_index(u, v)));
 }
 
 
@@ -3030,7 +3030,7 @@ irValue *ir_emit_uintptr_to_ptr(irProcedure *proc, irValue *value, Type *t) {
 
 void ir_emit_store_union_variant(irProcedure *proc, irValue *parent, irValue *variant, Type *variant_type) {
 	gbAllocator a = proc->module->allocator;
-	irValue *underlying = ir_emit_conv(proc, parent, make_type_pointer(a, variant_type));
+	irValue *underlying = ir_emit_conv(proc, parent, alloc_type_pointer(variant_type));
 
 	irValue *v = variant;
 	ir_emit_store(proc, underlying, variant);
@@ -3104,8 +3104,8 @@ irValue *ir_emit_conv(irProcedure *proc, irValue *value, Type *t) {
 	if (is_type_integer(src) && is_type_integer(dst)) {
 		GB_ASSERT(src->kind == Type_Basic &&
 		          dst->kind == Type_Basic);
-		i64 sz = type_size_of(proc->module->allocator, default_type(src));
-		i64 dz = type_size_of(proc->module->allocator, default_type(dst));
+		i64 sz = type_size_of(default_type(src));
+		i64 dz = type_size_of(default_type(dst));
 		irConvKind kind = irConv_trunc;
 
 		if (dz < sz) {
@@ -3157,8 +3157,8 @@ irValue *ir_emit_conv(irProcedure *proc, irValue *value, Type *t) {
 	// float -> float
 	if (is_type_float(src) && is_type_float(dst)) {
 		gbAllocator a = proc->module->allocator;
-		i64 sz = type_size_of(proc->module->allocator, src);
-		i64 dz = type_size_of(proc->module->allocator, dst);
+		i64 sz = type_size_of(src);
+		i64 dz = type_size_of(dst);
 		if (sz == 2) {
 			switch (dz) {
 			case 2: return value;
@@ -3265,7 +3265,7 @@ irValue *ir_emit_conv(irProcedure *proc, irValue *value, Type *t) {
 		// gb_printf("field_name: %.*s\n", LIT(field_name));
 		if (field_name.len > 0) {
 			// NOTE(bill): It can be casted
-			Selection sel = lookup_field(proc->module->allocator, st, field_name, false);
+			Selection sel = lookup_field(st, field_name, false);
 			if (sel.entity != nullptr) {
 				ir_emit_comment(proc, str_lit("cast - polymorphism"));
 				if (st_is_ptr) {
@@ -3429,8 +3429,8 @@ irValue *ir_emit_transmute(irProcedure *proc, irValue *value, Type *t) {
 
 	irModule *m = proc->module;
 
-	i64 sz = type_size_of(m->allocator, src);
-	i64 dz = type_size_of(m->allocator, dst);
+	i64 sz = type_size_of(src);
+	i64 dz = type_size_of(dst);
 
 	GB_ASSERT_MSG(sz == dz, "Invalid transmute conversion: '%s' to '%s'", type_to_string(src_type), type_to_string(t));
 
@@ -3444,7 +3444,7 @@ irValue *ir_emit_transmute(irProcedure *proc, irValue *value, Type *t) {
 
 	if (ir_is_type_aggregate(src) || ir_is_type_aggregate(dst)) {
 		irValue *s = ir_address_from_load_or_generate_local(proc, value);
-		irValue *d = ir_emit_bitcast(proc, s, make_type_pointer(m->allocator, t));
+		irValue *d = ir_emit_bitcast(proc, s, alloc_type_pointer(t));
 		return ir_emit_load(proc, d);
 	}
 
@@ -3464,7 +3464,7 @@ irValue *ir_emit_union_cast(irProcedure *proc, irValue *value, Type *type, Token
 	Type *tuple = type;
 	if (type->kind != Type_Tuple) {
 		is_tuple = false;
-		tuple = make_optional_ok_type(a, type);
+		tuple = make_optional_ok_type(type);
 	}
 
 	irValue *v = ir_add_local_generated(proc, tuple);
@@ -3533,7 +3533,7 @@ irAddr ir_emit_any_cast_addr(irProcedure *proc, irValue *value, Type *type, Toke
 	Type *tuple = type;
 	if (type->kind != Type_Tuple) {
 		is_tuple = false;
-		tuple = make_optional_ok_type(a, type);
+		tuple = make_optional_ok_type(type);
 	}
 	Type *dst_type = tuple->Tuple.variables[0]->type;
 
@@ -3553,7 +3553,7 @@ irAddr ir_emit_any_cast_addr(irProcedure *proc, irValue *value, Type *type, Toke
 	irValue *gep1 = ir_emit_struct_ep(proc, v, 1);
 
 	irValue *any_data = ir_emit_struct_ev(proc, value, 0);
-	irValue *ptr = ir_emit_conv(proc, any_data, make_type_pointer(a, dst_type));
+	irValue *ptr = ir_emit_conv(proc, any_data, alloc_type_pointer(dst_type));
 	ir_emit_store(proc, gep0, ir_emit_load(proc, ptr));
 	ir_emit_store(proc, gep1, v_true);
 
@@ -4029,7 +4029,7 @@ irValue *ir_emit_min(irProcedure *proc, Type *t, irValue *x, irValue *y) {
 
 	if (is_type_float(t)) {
 		gbAllocator a = proc->module->allocator;
-		i64 sz = 8*type_size_of(a, t);
+		i64 sz = 8*type_size_of(t);
 		auto args = array_make<irValue *>(proc->module->allocator, 2);
 		args[0] = x;
 		args[1] = y;
@@ -4047,7 +4047,7 @@ irValue *ir_emit_max(irProcedure *proc, Type *t, irValue *x, irValue *y) {
 
 	if (is_type_float(t)) {
 		gbAllocator a = proc->module->allocator;
-		i64 sz = 8*type_size_of(a, t);
+		i64 sz = 8*type_size_of(t);
 		auto args = array_make<irValue *>(proc->module->allocator, 2);
 		args[0] = x;
 		args[1] = y;
@@ -4254,10 +4254,10 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv
 				GB_ASSERT(allocation_type != nullptr);
 			}
 		}
-		Type *ptr_type = make_type_pointer(a, type);
+		Type *ptr_type = alloc_type_pointer(type);
 
-		i64 size  = type_size_of(a, allocation_type);
-		i64 align = type_align_of(a, allocation_type);
+		i64 size  = type_size_of(allocation_type);
+		i64 align = type_align_of(allocation_type);
 
 		irValue **args = gb_alloc_array(a, irValue *, 2);
 		args[0] = ir_const_int(a, size);
@@ -4266,7 +4266,7 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv
 		irValue *v = ir_emit_conv(proc, call, ptr_type);
 		if (type != allocation_type) {
 			Type *u = base_type(allocation_type);
-			Type *uptr_type = make_type_pointer(a, u);
+			Type *uptr_type = alloc_type_pointer(u);
 			irValue *parent = ir_emit_conv(proc, call, uptr_type);
 			irValue *tag_ptr = ir_emit_union_tag_ptr(proc, parent);
 			ir_emit_store(proc, tag_ptr, ir_const_int(a, variant_index));
@@ -4288,10 +4288,10 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv
 
 		if (is_type_slice(type)) {
 			Type *elem_type = core_type(type)->Slice.elem;
-			Type *elem_ptr_type = make_type_pointer(a, elem_type);
+			Type *elem_ptr_type = alloc_type_pointer(elem_type);
 
-			i64 esz = type_size_of(a, elem_type);
-			i64 eal = type_align_of(a, elem_type);
+			i64 esz = type_size_of(elem_type);
+			i64 eal = type_align_of(elem_type);
 
 			irValue *elem_size  = ir_const_int(a, esz);
 			irValue *elem_align = ir_const_int(a, eal);
@@ -4359,8 +4359,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv
 
 			auto args = array_make<irValue *>(proc->module->allocator, 6);
 			args[0] = ir_emit_conv(proc, array, t_rawptr);
-			args[1] = ir_const_int(a, type_size_of(a, elem_type));
-			args[2] = ir_const_int(a, type_align_of(a, elem_type));
+			args[1] = ir_const_int(a, type_size_of(elem_type));
+			args[2] = ir_const_int(a, type_align_of(elem_type));
 			args[3] = len;
 			args[4] = cap;
 			args[5] = ir_emit_source_code_location(proc, ce->args[0]);
@@ -4466,8 +4466,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv
 		if (is_type_dynamic_array(type)) {
 			Type *elem = type->DynamicArray.elem;
 
-			irValue *elem_size  = ir_const_int(a, type_size_of(a, elem));
-			irValue *elem_align = ir_const_int(a, type_align_of(a, elem));
+			irValue *elem_size  = ir_const_int(a, type_size_of(elem));
+			irValue *elem_align = ir_const_int(a, type_align_of(elem));
 
 			ptr = ir_emit_conv(proc, ptr, t_rawptr);
 
@@ -4546,8 +4546,8 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv
 			GB_PANIC("Invalid type to append");
 		}
 
-		irValue *elem_size  = ir_const_int(a, type_size_of(a, elem_type));
-		irValue *elem_align = ir_const_int(a, type_align_of(a, elem_type));
+		irValue *elem_size  = ir_const_int(a, type_size_of(elem_type));
+		irValue *elem_align = ir_const_int(a, type_align_of(elem_type));
 
 		array_ptr = ir_emit_conv(proc, array_ptr, t_rawptr);
 
@@ -4588,12 +4588,12 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv
 
 		if (!vari_expand) {
 			ir_emit_comment(proc, str_lit("variadic call argument generation"));
-			Type *slice_type = make_type_slice(a, elem_type);
+			Type *slice_type = alloc_type_slice(elem_type);
 			irValue *slice = ir_add_local_generated(proc, slice_type);
 			isize slice_len = arg_count-1;
 
 			if (slice_len > 0) {
-				irValue *base_array = ir_add_local_generated(proc, make_type_array(a, elem_type, slice_len));
+				irValue *base_array = ir_add_local_generated(proc, alloc_type_array(elem_type, slice_len));
 
 				for (isize i = 1; i < arg_count; i++) {
 					irValue *addr = ir_emit_array_epi(proc, base_array, i-1);
@@ -4759,7 +4759,7 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv
 		irValue *x = ir_build_expr(proc, ce->args[0]);
 		Type *t = ir_type(x);
 		if (is_type_complex(t)) {
-			i64 sz = 8*type_size_of(a, t);
+			i64 sz = 8*type_size_of(t);
 			auto args = array_make<irValue *>(proc->module->allocator, 1);
 			args[0] = x;
 			switch (sz) {
@@ -4768,7 +4768,7 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv
 			}
 			GB_PANIC("Unknown complex type");
 		} else if (is_type_float(t)) {
-			i64 sz = 8*type_size_of(a, t);
+			i64 sz = 8*type_size_of(t);
 			auto args = array_make<irValue *>(proc->module->allocator, 1);
 			args[0] = x;
 			switch (sz) {
@@ -5319,7 +5319,7 @@ irValue *ir_build_expr_internal(irProcedure *proc, AstNode *expr) {
 				isize slice_len = arg_count+1 - (variadic_index+1);
 
 				if (slice_len > 0) {
-					irValue *base_array = ir_add_local_generated(proc, make_type_array(allocator, elem_type, slice_len));
+					irValue *base_array = ir_add_local_generated(proc, alloc_type_array(elem_type, slice_len));
 
 					for (isize i = variadic_index, j = 0; i < arg_count; i++, j++) {
 						irValue *addr = ir_emit_array_epi(proc, base_array, cast(i32)j);
@@ -5375,7 +5375,7 @@ irValue *ir_get_using_variable(irProcedure *proc, Entity *e) {
 	GB_ASSERT(e->kind == Entity_Variable && e->flags & EntityFlag_Using);
 	String name = e->token.string;
 	Entity *parent = e->using_parent;
-	Selection sel = lookup_field(proc->module->allocator, parent->type, name, false);
+	Selection sel = lookup_field(parent->type, name, false);
 	GB_ASSERT(sel.entity != nullptr);
 	irValue **pv = map_get(&proc->module->values, hash_entity(parent));
 	irValue *v = nullptr;
@@ -5473,7 +5473,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
 
 			Type *type = base_type(tav.type);
 			if (tav.mode == Addressing_Type) { // Addressing_Type
-				Selection sel = lookup_field(proc->module->allocator, type, selector, true);
+				Selection sel = lookup_field(type, selector, true);
 				Entity *e = sel.entity;
 				GB_ASSERT(e->kind == Entity_Variable);
 				GB_ASSERT(e->flags & EntityFlag_TypeField);
@@ -5498,7 +5498,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
 				GB_PANIC("Unreachable");
 			}
 
-			Selection sel = lookup_field(proc->module->allocator, type, selector, false);
+			Selection sel = lookup_field(type, selector, false);
 			GB_ASSERT(sel.entity != nullptr);
 
 
@@ -5530,7 +5530,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
 			ExactValue val = type_and_value_of_expr(proc->module->info, sel).value;
 			i64 index = val.value_integer;
 
-			Selection sel = lookup_field_from_index(proc->module->allocator, type, index);
+			Selection sel = lookup_field_from_index(type, index);
 			GB_ASSERT(sel.entity != nullptr);
 
 			irValue *a = ir_build_addr_ptr(proc, se->expr);
@@ -5730,7 +5730,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
 
 		case Type_DynamicArray: {
 			Type *elem_type = type->DynamicArray.elem;
-			Type *slice_type = make_type_slice(a, elem_type);
+			Type *slice_type = alloc_type_slice(elem_type);
 
 			irValue *len = ir_dynamic_array_len(proc, base);
 			if (high == nullptr) high = len;
@@ -5747,7 +5747,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
 
 
 		case Type_Array: {
-			Type *slice_type = make_type_slice(a, type->Array.elem);
+			Type *slice_type = alloc_type_slice(type->Array.elem);
 			irValue *len = ir_array_len(proc, base);
 
 			if (high == nullptr) high = len;
@@ -5842,13 +5842,12 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
 					if (elem->kind == AstNode_FieldValue) {
 						ast_node(fv, FieldValue, elem);
 						String name = fv->field->Ident.token.string;
-						Selection sel = lookup_field(proc->module->allocator, bt, name, false);
+						Selection sel = lookup_field(bt, name, false);
 						index = sel.index[0];
 						elem = fv->value;
 					} else {
 						TypeAndValue tav = type_and_value_of_expr(proc->module->info, elem);
-						Selection sel = lookup_field_from_index(proc->module->allocator, bt,
-						                                        st->fields[field_index]->Variable.field_src_index);
+						Selection sel = lookup_field_from_index(bt, st->fields[field_index]->Variable.field_src_index);
 						index = sel.index[0];
 					}
 
@@ -5899,8 +5898,8 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
 			}
 			Type *elem = bt->DynamicArray.elem;
 			gbAllocator a = proc->module->allocator;
-			irValue *size  = ir_const_int(a, type_size_of(a, elem));
-			irValue *align = ir_const_int(a, type_align_of(a, elem));
+			irValue *size  = ir_const_int(a, type_size_of(elem));
+			irValue *align = ir_const_int(a, type_align_of(elem));
 			{
 				auto args = array_make<irValue *>(a, 5);
 				args[0] = ir_emit_conv(proc, v, t_rawptr);
@@ -5955,8 +5954,8 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
 		case Type_Slice: {
 			if (cl->elems.count > 0) {
 				Type *elem_type = bt->Slice.elem;
-				Type *elem_ptr_type = make_type_pointer(proc->module->allocator, elem_type);
-				Type *elem_ptr_ptr_type = make_type_pointer(proc->module->allocator, elem_ptr_type);
+				Type *elem_ptr_type = alloc_type_pointer(elem_type);
+				Type *elem_ptr_ptr_type = alloc_type_pointer(elem_ptr_type);
 				irValue *slice = ir_add_module_constant(proc->module, type, exact_value_compound(expr));
 				GB_ASSERT(slice->kind == irValue_ConstantSlice);
 
@@ -6003,12 +6002,12 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
 
 					if (elem->kind == AstNode_FieldValue) {
 						ast_node(fv, FieldValue, elem);
-						Selection sel = lookup_field(proc->module->allocator, bt, fv->field->Ident.token.string, false);
+						Selection sel = lookup_field(bt, fv->field->Ident.token.string, false);
 						index = sel.index[0];
 						elem = fv->value;
 					} else {
 						TypeAndValue tav = type_and_value_of_expr(proc->module->info, elem);
-						Selection sel = lookup_field(proc->module->allocator, bt, field_names[field_index], false);
+						Selection sel = lookup_field(bt, field_names[field_index], false);
 						index = sel.index[0];
 					}
 
@@ -6914,7 +6913,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) {
 			gbAllocator a = proc->module->allocator;
 			Type *t = tav.type;
 			GB_ASSERT(is_type_enum(t));
-			Type *enum_ptr = make_type_pointer(a, t);
+			Type *enum_ptr = alloc_type_pointer(t);
 			t = base_type(t);
 			Type *core_elem = core_type(t);
 			i64 enum_count = t->Enum.fields.count;
@@ -7240,7 +7239,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) {
 
 				Type *ct = case_entity->type;
 				if (any_or_not_ptr) {
-					ct = make_type_pointer(proc->module->allocator, ct);
+					ct = alloc_type_pointer(ct);
 				}
 				GB_ASSERT_MSG(is_type_pointer(ct), "%s", type_to_string(ct));
 				irValue *data = nullptr;
@@ -7314,7 +7313,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) {
 		irValue *next = ir_add_local_generated(proc, t_context);
 		ir_emit_store(proc, next, new_context);
 
-		Selection sel = lookup_field(proc->module->allocator, t_context, str_lit("parent"), false);
+		Selection sel = lookup_field(t_context, str_lit("parent"), false);
 		GB_ASSERT(sel.entity != nullptr);
 		irValue *parent_ptr = ir_emit_deep_field_gep(proc, next, sel);
 		ir_emit_store(proc, parent_ptr, prev);
@@ -7389,7 +7388,7 @@ void ir_begin_procedure_body(irProcedure *proc) {
 
 	if (proc->type->Proc.return_by_pointer) {
 		// NOTE(bill): this must be the first parameter stored
-		Type *ptr_type = make_type_pointer(a, reduce_tuple_to_single_type(proc->type->Proc.results));
+		Type *ptr_type = alloc_type_pointer(reduce_tuple_to_single_type(proc->type->Proc.results));
 		Entity *e = make_entity_param(a, nullptr, make_token_ident(str_lit("agg.result")), ptr_type, false, false);
 		e->flags |= EntityFlag_Sret | EntityFlag_NoAlias;
 
@@ -7634,7 +7633,7 @@ void ir_init_module(irModule *m, Checker *c) {
 			isize max_type_info_count = m->info->type_info_types.count;
 
 			String name = str_lit(IR_TYPE_INFO_DATA_NAME);
-			Entity *e = make_entity_variable(m->allocator, nullptr, make_token_ident(name), make_type_array(m->allocator, t_type_info, max_type_info_count), false);
+			Entity *e = make_entity_variable(m->allocator, nullptr, make_token_ident(name), alloc_type_array(t_type_info, max_type_info_count), false);
 			irValue *g = ir_value_global(m->allocator, e, nullptr);
 			g->Global.is_private = true;
 			ir_module_add_value(m, e, g);
@@ -7666,7 +7665,7 @@ void ir_init_module(irModule *m, Checker *c) {
 			{
 				String name = str_lit(IR_TYPE_INFO_TYPES_NAME);
 				Entity *e = make_entity_variable(m->allocator, nullptr, make_token_ident(name),
-				                                 make_type_array(m->allocator, t_type_info_ptr, count), false);
+				                                 alloc_type_array(t_type_info_ptr, count), false);
 				irValue *g = ir_value_global(m->allocator, e, nullptr);
 				ir_module_add_value(m, e, g);
 				map_set(&m->members, hash_string(name), g);
@@ -7675,7 +7674,7 @@ void ir_init_module(irModule *m, Checker *c) {
 			{
 				String name = str_lit(IR_TYPE_INFO_NAMES_NAME);
 				Entity *e = make_entity_variable(m->allocator, nullptr, make_token_ident(name),
-				                                 make_type_array(m->allocator, t_string, count), false);
+				                                 alloc_type_array(t_string, count), false);
 				irValue *g = ir_value_global(m->allocator, e, nullptr);
 				ir_module_add_value(m, e, g);
 				map_set(&m->members, hash_string(name), g);
@@ -7684,7 +7683,7 @@ void ir_init_module(irModule *m, Checker *c) {
 			{
 				String name = str_lit(IR_TYPE_INFO_OFFSETS_NAME);
 				Entity *e = make_entity_variable(m->allocator, nullptr, make_token_ident(name),
-				                                 make_type_array(m->allocator, t_uintptr, count), false);
+				                                 alloc_type_array(t_uintptr, count), false);
 				irValue *g = ir_value_global(m->allocator, e, nullptr);
 				ir_module_add_value(m, e, g);
 				map_set(&m->members, hash_string(name), g);
@@ -7694,7 +7693,7 @@ void ir_init_module(irModule *m, Checker *c) {
 			{
 				String name = str_lit(IR_TYPE_INFO_USINGS_NAME);
 				Entity *e = make_entity_variable(m->allocator, nullptr, make_token_ident(name),
-				                                 make_type_array(m->allocator, t_bool, count), false);
+				                                 alloc_type_array(t_bool, count), false);
 				irValue *g = ir_value_global(m->allocator, e, nullptr);
 				ir_module_add_value(m, e, g);
 				map_set(&m->members, hash_string(name), g);
@@ -7839,8 +7838,8 @@ void ir_setup_type_info_data(irProcedure *proc) { // NOTE(bill): Setup type_info
 
 
 	// Useful types
-	Type *t_i64_slice_ptr    = make_type_pointer(a, make_type_slice(a, t_i64));
-	Type *t_string_slice_ptr = make_type_pointer(a, make_type_slice(a, t_string));
+	Type *t_i64_slice_ptr    = alloc_type_pointer(alloc_type_slice(t_i64));
+	Type *t_string_slice_ptr = alloc_type_pointer(alloc_type_slice(t_string));
 
 	i32 type_info_member_types_index = 0;
 	i32 type_info_member_names_index = 0;
@@ -7859,8 +7858,8 @@ void ir_setup_type_info_data(irProcedure *proc) { // NOTE(bill): Setup type_info
 		irValue *ti_ptr = ir_emit_array_epi(proc, ir_global_type_info_data, cast(i32)entry_index);
 		irValue *variant_ptr = ir_emit_struct_ep(proc, ti_ptr, 2);
 
-		ir_emit_store(proc, ir_emit_struct_ep(proc, ti_ptr, 0), ir_const_int(a, type_size_of(a, t)));
-		ir_emit_store(proc, ir_emit_struct_ep(proc, ti_ptr, 1), ir_const_int(a, type_align_of(a, t)));
+		ir_emit_store(proc, ir_emit_struct_ep(proc, ti_ptr, 0), ir_const_int(a, type_size_of(t)));
+		ir_emit_store(proc, ir_emit_struct_ep(proc, ti_ptr, 1), ir_const_int(a, type_align_of(t)));
 
 
 		switch (t->kind) {
@@ -7953,7 +7952,7 @@ void ir_setup_type_info_data(irProcedure *proc) { // NOTE(bill): Setup type_info
 			irValue *gep = ir_get_type_info_ptr(proc, t->Array.elem);
 			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
 
-			isize ez = type_size_of(a, t->Array.elem);
+			isize ez = type_size_of(t->Array.elem);
 			irValue *elem_size = ir_emit_struct_ep(proc, tag, 1);
 			ir_emit_store(proc, elem_size, ir_const_int(a, ez));
 
@@ -7968,7 +7967,7 @@ void ir_setup_type_info_data(irProcedure *proc) { // NOTE(bill): Setup type_info
 			irValue *gep = ir_get_type_info_ptr(proc, t->DynamicArray.elem);
 			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
 
-			isize ez = type_size_of(a, t->DynamicArray.elem);
+			isize ez = type_size_of(t->DynamicArray.elem);
 			irValue *elem_size = ir_emit_struct_ep(proc, tag, 1);
 			ir_emit_store(proc, elem_size, ir_const_int(a, ez));
 			break;
@@ -7979,7 +7978,7 @@ void ir_setup_type_info_data(irProcedure *proc) { // NOTE(bill): Setup type_info
 			irValue *gep = ir_get_type_info_ptr(proc, t->Slice.elem);
 			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
 
-			isize ez = type_size_of(a, t->Slice.elem);
+			isize ez = type_size_of(t->Slice.elem);
 			irValue *elem_size = ir_emit_struct_ep(proc, tag, 1);
 			ir_emit_store(proc, elem_size, ir_const_int(a, ez));
 			break;
@@ -8103,12 +8102,12 @@ void ir_setup_type_info_data(irProcedure *proc) { // NOTE(bill): Setup type_info
 				irValue *count = ir_const_int(a, variant_count);
 				ir_fill_slice(proc, variant_types, memory_types, count);
 
-				i64 tag_size   = union_tag_size(a, t);
+				i64 tag_size   = union_tag_size(t);
 				i64 tag_offset = align_formula(t->Union.variant_block_size, tag_size);
 
 				if (tag_size > 0) {
 					ir_emit_store(proc, tag_offset_ptr, ir_const_uintptr(a, tag_offset));
-					ir_emit_store(proc, tag_type_ptr,   ir_type_info(proc, union_tag_type(a, t)));
+					ir_emit_store(proc, tag_type_ptr,   ir_type_info(proc, union_tag_type(t)));
 				}
 			}
 
@@ -8135,7 +8134,7 @@ void ir_setup_type_info_data(irProcedure *proc) { // NOTE(bill): Setup type_info
 			irValue *memory_offsets = ir_type_info_member_offsets_offset(proc, count);
 			irValue *memory_usings  = ir_type_info_member_usings_offset (proc, count);
 
-			type_set_offsets(a, t); // NOTE(bill): Just incase the offsets have not been set yet
+			type_set_offsets(t); // NOTE(bill): Just incase the offsets have not been set yet
 			for (isize source_index = 0; source_index < count; source_index++) {
 				// TODO(bill): Order fields in source order not layout order
 				Entity *f = t->Struct.fields[source_index];
@@ -8170,7 +8169,7 @@ void ir_setup_type_info_data(irProcedure *proc) { // NOTE(bill): Setup type_info
 		case Type_Map: {
 			ir_emit_comment(proc, str_lit("Type_Info_Map"));
 			tag = ir_emit_conv(proc, variant_ptr, t_type_info_map_ptr);
-			generate_map_internal_types(a, t);
+			init_map_internal_types(t);
 
 			irValue *key              = ir_emit_struct_ep(proc, tag, 0);
 			irValue *value            = ir_emit_struct_ep(proc, tag, 1);
@@ -8480,8 +8479,8 @@ void ir_gen_tree(irGen *s) {
 	if (build_context.is_dll && !has_dll_main) {
 		// DllMain :: proc(inst: rawptr, reason: u32, reserved: rawptr) -> i32
 		String name = str_lit("DllMain");
-		Type *proc_params = make_type_tuple(a);
-		Type *proc_results = make_type_tuple(a);
+		Type *proc_params = alloc_type_tuple();
+		Type *proc_results = alloc_type_tuple();
 
 		Scope *proc_scope = gb_alloc_item(a, Scope);
 
@@ -8496,9 +8495,9 @@ void ir_gen_tree(irGen *s) {
 		proc_results->Tuple.variables[0] = make_entity_param(a, proc_scope, empty_token, t_i32, false, false);
 
 
-		Type *proc_type = make_type_proc(a, proc_scope,
-		                                 proc_params, 3,
-		                                 proc_results, 1, false, ProcCC_StdCall);
+		Type *proc_type = alloc_type_proc(proc_scope,
+		                                  proc_params, 3,
+		                                  proc_results, 1, false, ProcCC_StdCall);
 
 		// TODO(bill): make this more robust
 		proc_type->Proc.abi_compat_params = array_make<Type *>(a, proc_params->Tuple.variables.count);
@@ -8558,15 +8557,15 @@ void ir_gen_tree(irGen *s) {
 			name = str_lit("ProgramEntry");
 		}
 
-		Type *proc_params = make_type_tuple(a);
-		Type *proc_results = make_type_tuple(a);
+		Type *proc_params = alloc_type_tuple();
+		Type *proc_results = alloc_type_tuple();
 
 		Scope *proc_scope = gb_alloc_item(a, Scope);
 
 		array_init(&proc_params->Tuple.variables, a, 2);
 		array_init(&proc_results->Tuple.variables, a, 1);
 
-		Type *cstring_ptr = make_type_pointer(a, t_cstring);
+		Type *cstring_ptr = alloc_type_pointer(t_cstring);
 		proc_params->Tuple.variables[0] = make_entity_param(a, proc_scope, make_token_ident(str_lit("argc")), t_i32, false, false);
 		proc_params->Tuple.variables[1] = make_entity_param(a, proc_scope, make_token_ident(str_lit("argv")), cstring_ptr, false, false);
 
@@ -8574,9 +8573,9 @@ void ir_gen_tree(irGen *s) {
 		proc_results->Tuple.variables[0] = make_entity_param(a, proc_scope, empty_token, t_i32, false, false);
 
 
-		Type *proc_type = make_type_proc(a, proc_scope,
-		                                 proc_params, 2,
-		                                 proc_results, 1, false, ProcCC_CDecl);
+		Type *proc_type = alloc_type_proc(proc_scope,
+		                                  proc_params, 2,
+		                                  proc_results, 1, false, ProcCC_CDecl);
 
 		// TODO(bill): make this more robust
 		proc_type->Proc.abi_compat_params = array_make<Type *>(a, proc_params->Tuple.variables.count);
@@ -8626,8 +8625,8 @@ void ir_gen_tree(irGen *s) {
 	if (!m->build_context->is_dll && !has_win_main) {
 		// proc WinMain(inst, prev: rawptr, cmd_line: ^byte, cmd_show: i32) -> i32
 		String name = str_lit("WinMain");
-		Type *proc_params = make_type_tuple(a);
-		Type *proc_results = make_type_tuple(a);
+		Type *proc_params = alloc_type_tuple();
+		Type *proc_results = alloc_type_tuple();
 
 		Scope *proc_scope = gb_alloc_item(a, Scope);
 
@@ -8645,7 +8644,7 @@ void ir_gen_tree(irGen *s) {
 		proc_results->Tuple.variables[0] = make_entity_param(a, proc_scope, empty_token, t_i32, false);
 
 
-		Type *proc_type = make_type_proc(a, proc_scope,
+		Type *proc_type = alloc_type_proc(a, proc_scope,
 		                                 proc_params, 4,
 		                                 proc_results, 1, false, ProcCC_Std);
 
@@ -8671,10 +8670,10 @@ void ir_gen_tree(irGen *s) {
 	{ // Startup Runtime
 		// Cleanup(bill): probably better way of doing code insertion
 		String name = str_lit(IR_STARTUP_RUNTIME_PROC_NAME);
-		Type *proc_type = make_type_proc(a, gb_alloc_item(a, Scope),
-		                                 nullptr, 0,
-		                                 nullptr, 0, false,
-		                                 ProcCC_Contextless);
+		Type *proc_type = alloc_type_proc(gb_alloc_item(a, Scope),
+		                                  nullptr, 0,
+		                                  nullptr, 0, false,
+		                                  ProcCC_Contextless);
 		AstNode *body = gb_alloc_item(a, AstNode);
 		Entity *e = make_entity_procedure(a, nullptr, make_token_ident(name), proc_type, 0);
 		irValue *p = ir_value_procedure(a, m, e, proc_type, nullptr, body, name);

src/ir_print.cpp

@@ -385,13 +385,13 @@ void ir_print_type(irFileBuffer *f, irModule *m, Type *t, bool in_struct) {
 		} else {
 			// NOTE(bill): The zero size array is used to fix the alignment used in a structure as
 			// LLVM takes the first element's alignment as the entire alignment (like C)
-			i64 align = type_align_of(heap_allocator(), t);
+			i64 align = type_align_of(t);
 			i64 block_size =  t->Union.variant_block_size;
 
 			ir_fprintf(f, "{[0 x <%lld x i8>], ", align);
 			ir_fprintf(f, "[%lld x i8], ", block_size);
 			// ir_print_type(f, m, t_type_info_ptr);
-			ir_print_type(f, m, union_tag_type(m->allocator, t));
+			ir_print_type(f, m, union_tag_type(t));
 			ir_write_byte(f, '}');
 		}
 		return;
@@ -400,8 +400,8 @@ void ir_print_type(irFileBuffer *f, irModule *m, Type *t, bool in_struct) {
 		if (t->Struct.is_raw_union) {
 			// NOTE(bill): The zero size array is used to fix the alignment used in a structure as
 			// LLVM takes the first element's alignment as the entire alignment (like C)
-			i64 size_of_union  = type_size_of(heap_allocator(), t);
-			i64 align_of_union = type_align_of(heap_allocator(), t);
+			i64 size_of_union  = type_size_of(t);
+			i64 align_of_union = type_align_of(t);
 			ir_fprintf(f, "{[0 x <%lld x i8>], [%lld x i8]}", align_of_union, size_of_union);
 			return;
 		} else {
@@ -481,14 +481,14 @@ void ir_print_type(irFileBuffer *f, irModule *m, Type *t, bool in_struct) {
 		return;
 
 	case Type_Map:
-		generate_map_internal_types(m->allocator, t);
+		init_map_internal_types(t);
 		GB_ASSERT(t->Map.internal_type != nullptr);
 		ir_print_type(f, m, t->Map.internal_type);
 		break;
 
 	case Type_BitField: {
-		i64 align = type_align_of(heap_allocator(), t);
-		i64 size  = type_size_of(heap_allocator(),  t);
+		i64 align = type_align_of(t);
+		i64 size  = type_size_of(t);
 		ir_fprintf(f, "{[0 x <%lld x i8>], [%lld x i8]}", align, size);
 		break;
 	}
@@ -723,7 +723,7 @@ void ir_print_exact_value(irFileBuffer *f, irModule *m, ExactValue value, Type *
 						TypeAndValue tav = type_and_value_of_expr(m->info, fv->value);
 						GB_ASSERT(tav.mode != Addressing_Invalid);
 
-						Selection sel = lookup_field(m->allocator, type, name, false);
+						Selection sel = lookup_field(type, name, false);
 						Entity *f = type->Struct.fields[sel.index[0]];
 
 						values[f->Variable.field_index] = tav.value;
@@ -998,7 +998,7 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) {
 		Type *type = instr->Local.entity->type;
 		i64 align = instr->Local.alignment;
 		if (align <= 0) {
-			align = type_align_of(m->allocator, type);
+			align = type_align_of(type);
 		}
 		ir_fprintf(f, "%%%d = alloca ", value->index);
 		ir_print_type(f, m, type);
@@ -1040,7 +1040,7 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) {
 		ir_print_type(f, m, type);
 		ir_write_str_lit(f, "* ");
 		ir_print_value(f, m, instr->Load.address, type);
-		ir_fprintf(f, ", align %lld", type_align_of(m->allocator, type));
+		ir_fprintf(f, ", align %lld", type_align_of(type));
 		ir_print_debug_location(f, m, value);
 		break;
 	}

src/types.cpp

@@ -410,11 +410,11 @@ gb_global Type *t_map_header                  = nullptr;
 
 
 
-i64      type_size_of               (gbAllocator allocator, Type *t);
-i64      type_align_of              (gbAllocator allocator, Type *t);
-i64      type_offset_of             (gbAllocator allocator, Type *t, i32 index);
+i64      type_size_of               (Type *t);
+i64      type_align_of              (Type *t);
+i64      type_offset_of             (Type *t, i32 index);
 gbString type_to_string             (Type *type);
-void     generate_map_internal_types(gbAllocator a, Type *type);
+void     init_map_internal_types(Type *type);
 
 
 
@@ -472,7 +472,8 @@ void set_base_type(Type *t, Type *base) {
 }
 
 
-Type *alloc_type(gbAllocator a, TypeKind kind) {
+Type *alloc_type(TypeKind kind) {
+	gbAllocator a = heap_allocator();
 	Type *t = gb_alloc_item(a, Type);
 	gb_zero_item(t);
 	t->kind = kind;
@@ -482,8 +483,8 @@ Type *alloc_type(gbAllocator a, TypeKind kind) {
 }
 
 
-Type *make_type_generic(gbAllocator a, Scope *scope, i64 id, String name, Type *specialized) {
-	Type *t = alloc_type(a, Type_Generic);
+Type *alloc_type_generic(Scope *scope, i64 id, String name, Type *specialized) {
+	Type *t = alloc_type(Type_Generic);
 	t->Generic.id = id;
 	t->Generic.name = name;
 	t->Generic.specialized = specialized;
@@ -491,45 +492,45 @@ Type *make_type_generic(gbAllocator a, Scope *scope, i64 id, String name, Type *
 	return t;
 }
 
-Type *make_type_pointer(gbAllocator a, Type *elem) {
-	Type *t = alloc_type(a, Type_Pointer);
+Type *alloc_type_pointer(Type *elem) {
+	Type *t = alloc_type(Type_Pointer);
 	t->Pointer.elem = elem;
 	return t;
 }
 
-Type *make_type_array(gbAllocator a, Type *elem, i64 count, Type *generic_type = nullptr) {
-	Type *t = alloc_type(a, Type_Array);
+Type *alloc_type_array(Type *elem, i64 count, Type *generic_type = nullptr) {
+	Type *t = alloc_type(Type_Array);
 	t->Array.elem = elem;
 	t->Array.count = count;
 	t->Array.generic_type = generic_type;
 	return t;
 }
 
-Type *make_type_dynamic_array(gbAllocator a, Type *elem) {
-	Type *t = alloc_type(a, Type_DynamicArray);
+Type *alloc_type_dynamic_array(Type *elem) {
+	Type *t = alloc_type(Type_DynamicArray);
 	t->DynamicArray.elem = elem;
 	return t;
 }
 
-Type *make_type_slice(gbAllocator a, Type *elem) {
-	Type *t = alloc_type(a, Type_Slice);
+Type *alloc_type_slice(Type *elem) {
+	Type *t = alloc_type(Type_Slice);
 	t->Array.elem = elem;
 	return t;
 }
 
 
-Type *make_type_struct(gbAllocator a) {
-	Type *t = alloc_type(a, Type_Struct);
+Type *alloc_type_struct() {
+	Type *t = alloc_type(Type_Struct);
 	return t;
 }
 
-Type *make_type_union(gbAllocator a) {
-	Type *t = alloc_type(a, Type_Union);
+Type *alloc_type_union() {
+	Type *t = alloc_type(Type_Union);
 	return t;
 }
 
-Type *make_type_enum(gbAllocator a) {
-	Type *t = alloc_type(a, Type_Enum);
+Type *alloc_type_enum() {
+	Type *t = alloc_type(Type_Enum);
 	return t;
 }
 
@@ -537,21 +538,21 @@ Type *make_type_enum(gbAllocator a) {
 
 
 
-Type *make_type_named(gbAllocator a, String name, Type *base, Entity *type_name) {
-	Type *t = alloc_type(a, Type_Named);
+Type *alloc_type_named(String name, Type *base, Entity *type_name) {
+	Type *t = alloc_type(Type_Named);
 	t->Named.name = name;
 	t->Named.base = base;
 	t->Named.type_name = type_name;
 	return t;
 }
 
-Type *make_type_tuple(gbAllocator a) {
-	Type *t = alloc_type(a, Type_Tuple);
+Type *alloc_type_tuple() {
+	Type *t = alloc_type(Type_Tuple);
 	return t;
 }
 
-Type *make_type_proc(gbAllocator a, Scope *scope, Type *params, isize param_count, Type *results, isize result_count, bool variadic, ProcCallingConvention calling_convention) {
-	Type *t = alloc_type(a, Type_Proc);
+Type *alloc_type_proc(Scope *scope, Type *params, isize param_count, Type *results, isize result_count, bool variadic, ProcCallingConvention calling_convention) {
+	Type *t = alloc_type(Type_Proc);
 
 	if (variadic) {
 		if (param_count == 0) {
@@ -577,8 +578,8 @@ Type *make_type_proc(gbAllocator a, Scope *scope, Type *params, isize param_coun
 
 bool is_type_valid_for_keys(Type *t);
 
-Type *make_type_map(gbAllocator a, i64 count, Type *key, Type *value) {
-	Type *t = alloc_type(a, Type_Map);
+Type *alloc_type_map(i64 count, Type *key, Type *value) {
+	Type *t = alloc_type(Type_Map);
 	if (key != nullptr) {
 		GB_ASSERT(is_type_valid_for_keys(key));
 	}
@@ -587,14 +588,14 @@ Type *make_type_map(gbAllocator a, i64 count, Type *key, Type *value) {
 	return t;
 }
 
-Type *make_type_bit_field_value(gbAllocator a, u32 bits) {
-	Type *t = alloc_type(a, Type_BitFieldValue);
+Type *alloc_type_bit_field_value(u32 bits) {
+	Type *t = alloc_type(Type_BitFieldValue);
 	t->BitFieldValue.bits = bits;
 	return t;
 }
 
-Type *make_type_bit_field(gbAllocator a) {
-	Type *t = alloc_type(a, Type_BitField);
+Type *alloc_type_bit_field() {
+	Type *t = alloc_type(Type_BitField);
 	return t;
 }
 
@@ -1396,7 +1397,7 @@ i64 union_variant_index(Type *u, Type *v) {
 	return 0;
 }
 
-i64 union_tag_size(gbAllocator a, Type *u) {
+i64 union_tag_size(Type *u) {
 	u = base_type(u);
 	GB_ASSERT(u->kind == Type_Union);
 	if (u->Union.tag_size > 0) {
@@ -1415,8 +1416,8 @@ i64 union_tag_size(gbAllocator a, Type *u) {
 	return tag_size;
 }
 
-Type *union_tag_type(gbAllocator a, Type *u) {
-	i64 s = union_tag_size(a, u);
+Type *union_tag_type(Type *u) {
+	i64 s = union_tag_size(u);
 	switch (s) {
 	case  1: return  t_u8;
 	case  2: return  t_u16;
@@ -1511,16 +1512,17 @@ ProcTypeOverloadKind are_proc_types_overload_safe(Type *x, Type *y) {
 
 
 
-Selection lookup_field_with_selection(gbAllocator a, Type *type_, String field_name, bool is_type, Selection sel);
+Selection lookup_field_with_selection(Type *type_, String field_name, bool is_type, Selection sel);
 
-Selection lookup_field(gbAllocator a, Type *type_, String field_name, bool is_type) {
-	return lookup_field_with_selection(a, type_, field_name, is_type, empty_selection);
+Selection lookup_field(Type *type_, String field_name, bool is_type) {
+	return lookup_field_with_selection(type_, field_name, is_type, empty_selection);
 }
 
-Selection lookup_field_from_index(gbAllocator a, Type *type, i64 index) {
+Selection lookup_field_from_index(Type *type, i64 index) {
 	GB_ASSERT(is_type_struct(type) || is_type_union(type) || is_type_tuple(type));
 	type = base_type(type);
 
+	gbAllocator a = heap_allocator();
 	isize max_count = 0;
 	switch (type->kind) {
 	case Type_Struct:   max_count = type->Struct.fields.count;   break;
@@ -1574,13 +1576,14 @@ gb_global Entity *entity__any_type_info  = nullptr;
 
 Entity *current_scope_lookup_entity(Scope *s, String name);
 
-Selection lookup_field_with_selection(gbAllocator a, Type *type_, String field_name, bool is_type, Selection sel) {
+Selection lookup_field_with_selection(Type *type_, String field_name, bool is_type, Selection sel) {
 	GB_ASSERT(type_ != nullptr);
 
 	if (is_blank_ident(field_name)) {
 		return empty_selection;
 	}
 
+	gbAllocator a = heap_allocator();
 	Type *type = type_deref(type_);
 	bool is_ptr = type != type_;
 	sel.indirect = sel.indirect || is_ptr;
@@ -1701,7 +1704,7 @@ Selection lookup_field_with_selection(gbAllocator a, Type *type_, String field_n
 		}
 		if (type->kind == Type_Generic && type->Generic.specialized != nullptr) {
 			Type *specialized = type->Generic.specialized;
-			return lookup_field_with_selection(a, specialized, field_name, is_type, sel);
+			return lookup_field_with_selection(specialized, field_name, is_type, sel);
 		}
 
 	} else if (type->kind == Type_Union) {
@@ -1723,7 +1726,7 @@ Selection lookup_field_with_selection(gbAllocator a, Type *type_, String field_n
 				isize prev_count = sel.index.count;
 				selection_add_index(&sel, i); // HACK(bill): Leaky memory
 
-				sel = lookup_field_with_selection(a, f->type, field_name, is_type, sel);
+				sel = lookup_field_with_selection(f->type, field_name, is_type, sel);
 
 				if (sel.entity != nullptr) {
 					if (is_type_pointer(f->type)) {
@@ -1817,12 +1820,12 @@ void type_path_pop(TypePath *tp) {
 #define FAILURE_ALIGNMENT 0
 
 
-i64 type_size_of_internal (gbAllocator allocator, Type *t, TypePath *path);
-i64 type_align_of_internal(gbAllocator allocator, Type *t, TypePath *path);
+i64 type_size_of_internal (Type *t, TypePath *path);
+i64 type_align_of_internal(Type *t, TypePath *path);
 
 
 
-i64 type_size_of(gbAllocator allocator, Type *t) {
+i64 type_size_of(Type *t) {
 	if (t == nullptr) {
 		return 0;
 	}
@@ -1832,12 +1835,12 @@ i64 type_size_of(gbAllocator allocator, Type *t) {
 	}
 	TypePath path = {0};
 	type_path_init(&path);
-	t->cached_size = type_size_of_internal(allocator, t, &path);
+	t->cached_size = type_size_of_internal(t, &path);
 	type_path_free(&path);
 	return t->cached_size;
 }
 
-i64 type_align_of(gbAllocator allocator, Type *t) {
+i64 type_align_of(Type *t) {
 	if (t == nullptr) {
 		return 1;
 	}
@@ -1848,13 +1851,13 @@ i64 type_align_of(gbAllocator allocator, Type *t) {
 
 	TypePath path = {0};
 	type_path_init(&path);
-	t->cached_align = type_align_of_internal(allocator, t, &path);
+	t->cached_align = type_align_of_internal(t, &path);
 	type_path_free(&path);
 	return t->cached_align;
 }
 
 
-i64 type_align_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
+i64 type_align_of_internal(Type *t, TypePath *path) {
 	GB_ASSERT(path != nullptr);
 	if (t->failure) {
 		return FAILURE_ALIGNMENT;
@@ -1874,7 +1877,7 @@ i64 type_align_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
 			return build_context.word_size;
 
 		case Basic_complex64: case Basic_complex128:
-			return type_size_of_internal(allocator, t, path) / 2;
+			return type_size_of_internal(t, path) / 2;
 		}
 	} break;
 
@@ -1884,7 +1887,7 @@ i64 type_align_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
 		if (path->failure) {
 			return FAILURE_ALIGNMENT;
 		}
-		i64 align = type_align_of_internal(allocator, t->Array.elem, path);
+		i64 align = type_align_of_internal(t->Array.elem, path);
 		if (pop) type_path_pop(path);
 		return align;
 	}
@@ -1900,7 +1903,7 @@ i64 type_align_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
 	case Type_Tuple: {
 		i64 max = 1;
 		for_array(i, t->Tuple.variables) {
-			i64 align = type_align_of_internal(allocator, t->Tuple.variables[i]->type, path);
+			i64 align = type_align_of_internal(t->Tuple.variables[i]->type, path);
 			if (max < align) {
 				max = align;
 			}
@@ -1909,10 +1912,10 @@ i64 type_align_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
 	} break;
 
 	case Type_Map:
-		generate_map_internal_types(allocator, t);
-		return type_align_of_internal(allocator, t->Map.internal_type, path);
+		init_map_internal_types(t);
+		return type_align_of_internal(t->Map.internal_type, path);
 	case Type_Enum:
-		return type_align_of_internal(allocator, t->Enum.base_type, path);
+		return type_align_of_internal(t->Enum.base_type, path);
 
 	case Type_Union: {
 		if (t->Union.variants.count == 0) {
@@ -1929,7 +1932,7 @@ i64 type_align_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
 			if (path->failure) {
 				return FAILURE_ALIGNMENT;
 			}
-			i64 align = type_align_of_internal(allocator, variant, path);
+			i64 align = type_align_of_internal(variant, path);
 			if (pop) type_path_pop(path);
 			if (max < align) {
 				max = align;
@@ -1950,7 +1953,7 @@ i64 type_align_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
 				if (path->failure) {
 					return FAILURE_ALIGNMENT;
 				}
-				i64 align = type_align_of_internal(allocator, field_type, path);
+				i64 align = type_align_of_internal(field_type, path);
 				if (pop) type_path_pop(path);
 				if (max < align) {
 					max = align;
@@ -1964,7 +1967,7 @@ i64 type_align_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
 				Type *field_type = t->Struct.fields[i]->type;
 				bool pop = type_path_push(path, field_type);
 				if (path->failure) return FAILURE_ALIGNMENT;
-				i64 align = type_align_of_internal(allocator, field_type, path);
+				i64 align = type_align_of_internal(field_type, path);
 				if (pop) type_path_pop(path);
 				if (max < align) {
 					max = align;
@@ -1986,14 +1989,15 @@ i64 type_align_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
 	} break;
 	}
 
-	// return gb_clamp(next_pow2(type_size_of(allocator, t)), 1, build_context.max_align);
+	// return gb_clamp(next_pow2(type_size_of(t)), 1, build_context.max_align);
 	// NOTE(bill): Things that are bigger than build_context.word_size, are actually comprised of smaller types
 	// TODO(bill): Is this correct for 128-bit types (integers)?
-	return gb_clamp(next_pow2(type_size_of_internal(allocator, t, path)), 1, build_context.word_size);
+	return gb_clamp(next_pow2(type_size_of_internal(t, path)), 1, build_context.word_size);
 }
 
-Array<i64> type_set_offsets_of(gbAllocator allocator, Array<Entity *> fields, bool is_packed, bool is_raw_union) {
-	auto offsets = array_make<i64>(allocator, fields.count);
+Array<i64> type_set_offsets_of(Array<Entity *> fields, bool is_packed, bool is_raw_union) {
+	gbAllocator a = heap_allocator();
+	auto offsets = array_make<i64>(a, fields.count);
 	i64 curr_offset = 0;
 	if (is_raw_union) {
 		for_array(i, fields) {
@@ -2001,15 +2005,15 @@ Array<i64> type_set_offsets_of(gbAllocator allocator, Array<Entity *> fields, bo
 		}
 	} else if (is_packed) {
 		for_array(i, fields) {
-			i64 size = type_size_of(allocator, fields[i]->type);
+			i64 size = type_size_of(fields[i]->type);
 			offsets[i] = curr_offset;
 			curr_offset += size;
 		}
 	} else {
 		for_array(i, fields) {
 			Type *t = fields[i]->type;
-			i64 align = gb_max(type_align_of(allocator, t), 1);
-			i64 size  = gb_max(type_size_of(allocator,  t), 0);
+			i64 align = gb_max(type_align_of(t), 1);
+			i64 size  = gb_max(type_size_of( t), 0);
 			curr_offset = align_formula(curr_offset, align);
 			offsets[i] = curr_offset;
 			curr_offset += size;
@@ -2018,12 +2022,12 @@ Array<i64> type_set_offsets_of(gbAllocator allocator, Array<Entity *> fields, bo
 	return offsets;
 }
 
-bool type_set_offsets(gbAllocator allocator, Type *t) {
+bool type_set_offsets(Type *t) {
 	t = base_type(t);
 	if (t->kind == Type_Struct) {
 		if (!t->Struct.are_offsets_set) {
 			t->Struct.are_offsets_being_processed = true;
-			t->Struct.offsets = type_set_offsets_of(allocator, t->Struct.fields, t->Struct.is_packed, t->Struct.is_raw_union);
+			t->Struct.offsets = type_set_offsets_of(t->Struct.fields, t->Struct.is_packed, t->Struct.is_raw_union);
 			t->Struct.are_offsets_being_processed = false;
 			t->Struct.are_offsets_set = true;
 			return true;
@@ -2031,7 +2035,7 @@ bool type_set_offsets(gbAllocator allocator, Type *t) {
 	} else if (is_type_tuple(t)) {
 		if (!t->Tuple.are_offsets_set) {
 			t->Struct.are_offsets_being_processed = true;
-			t->Tuple.offsets = type_set_offsets_of(allocator, t->Tuple.variables, false, false);
+			t->Tuple.offsets = type_set_offsets_of(t->Tuple.variables, false, false);
 			t->Struct.are_offsets_being_processed = false;
 			t->Tuple.are_offsets_set = true;
 			return true;
@@ -2042,7 +2046,7 @@ bool type_set_offsets(gbAllocator allocator, Type *t) {
 	return false;
 }
 
-i64 type_size_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
+i64 type_size_of_internal(Type *t, TypePath *path) {
 	if (t->failure) {
 		return FAILURE_SIZE;
 	}
@@ -2053,7 +2057,7 @@ i64 type_size_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
 		if (path->failure) {
 			return FAILURE_ALIGNMENT;
 		}
-		i64 size = type_size_of_internal(allocator, t->Named.base, path);
+		i64 size = type_size_of_internal(t->Named.base, path);
 		if (pop) type_path_pop(path);
 		return size;
 	} break;
@@ -2084,11 +2088,11 @@ i64 type_size_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
 		if (count == 0) {
 			return 0;
 		}
-		align = type_align_of_internal(allocator, t->Array.elem, path);
+		align = type_align_of_internal(t->Array.elem, path);
 		if (path->failure) {
 			return FAILURE_SIZE;
 		}
-		size  = type_size_of_internal( allocator, t->Array.elem, path);
+		size  = type_size_of_internal( t->Array.elem, path);
 		alignment = align_formula(size, align);
 		return alignment*(count-1) + size;
 	} break;
@@ -2101,8 +2105,8 @@ i64 type_size_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
 		return 3*build_context.word_size + 2*build_context.word_size;
 
 	case Type_Map:
-		generate_map_internal_types(allocator, t);
-		return type_size_of_internal(allocator, t->Map.internal_type, path);
+		init_map_internal_types(t);
+		return type_size_of_internal(t->Map.internal_type, path);
 
 	case Type_Tuple: {
 		i64 count, align, size;
@@ -2110,20 +2114,20 @@ i64 type_size_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
 		if (count == 0) {
 			return 0;
 		}
-		align = type_align_of_internal(allocator, t, path);
-		type_set_offsets(allocator, t);
-		size = t->Tuple.offsets[count-1] + type_size_of_internal(allocator, t->Tuple.variables[count-1]->type, path);
+		align = type_align_of_internal(t, path);
+		type_set_offsets(t);
+		size = t->Tuple.offsets[count-1] + type_size_of_internal(t->Tuple.variables[count-1]->type, path);
 		return align_formula(size, align);
 	} break;
 
 	case Type_Enum:
-		return type_size_of_internal(allocator, t->Enum.base_type, path);
+		return type_size_of_internal(t->Enum.base_type, path);
 
 	case Type_Union: {
 		if (t->Union.variants.count == 0) {
 			return 0;
 		}
-		i64 align = type_align_of_internal(allocator, t, path);
+		i64 align = type_align_of_internal(t, path);
 		if (path->failure) {
 			return FAILURE_SIZE;
 		}
@@ -2133,14 +2137,14 @@ i64 type_size_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
 
 		for_array(i, t->Union.variants) {
 			Type *variant_type = t->Union.variants[i];
-			i64 size = type_size_of_internal(allocator, variant_type, path);
+			i64 size = type_size_of_internal(variant_type, path);
 			if (max < size) {
 				max = size;
 			}
 		}
 
 		// NOTE(bill): Align to tag
-		i64 tag_size = union_tag_size(allocator, t);
+		i64 tag_size = union_tag_size(t);
 		i64 size = align_formula(max, tag_size);
 		// NOTE(bill): Calculate the padding between the common fields and the tag
 		t->Union.tag_size = tag_size;
@@ -2153,13 +2157,13 @@ i64 type_size_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
 	case Type_Struct: {
 		if (t->Struct.is_raw_union) {
 			i64 count = t->Struct.fields.count;
-			i64 align = type_align_of_internal(allocator, t, path);
+			i64 align = type_align_of_internal(t, path);
 			if (path->failure) {
 				return FAILURE_SIZE;
 			}
 			i64 max = 0;
 			for (isize i = 0; i < count; i++) {
-				i64 size = type_size_of_internal(allocator, t->Struct.fields[i]->type, path);
+				i64 size = type_size_of_internal(t->Struct.fields[i]->type, path);
 				if (max < size) {
 					max = size;
 				}
@@ -2173,7 +2177,7 @@ i64 type_size_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
 			if (count == 0) {
 				return 0;
 			}
-			align = type_align_of_internal(allocator, t, path);
+			align = type_align_of_internal(t, path);
 			if (path->failure) {
 				return FAILURE_SIZE;
 			}
@@ -2181,14 +2185,14 @@ i64 type_size_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
 				type_path_print_illegal_cycle(path, path->path.count-1);
 				return FAILURE_SIZE;
 			}
-			type_set_offsets(allocator, t);
-			size = t->Struct.offsets[count-1] + type_size_of_internal(allocator, t->Struct.fields[count-1]->type, path);
+			type_set_offsets(t);
+			size = t->Struct.offsets[count-1] + type_size_of_internal(t->Struct.fields[count-1]->type, path);
 			return align_formula(size, align);
 		}
 	} break;
 
 	case Type_BitField: {
-		i64 align = 8*type_align_of_internal(allocator, t, path);
+		i64 align = 8*type_align_of_internal(t, path);
 		i64 end = 0;
 		if (t->BitField.fields.count > 0) {
 			i64 last = t->BitField.fields.count-1;
@@ -2204,15 +2208,15 @@ i64 type_size_of_internal(gbAllocator allocator, Type *t, TypePath *path) {
 	return build_context.word_size;
 }
 
-i64 type_offset_of(gbAllocator allocator, Type *t, i32 index) {
+i64 type_offset_of(Type *t, i32 index) {
 	t = base_type(t);
 	if (t->kind == Type_Struct) {
-		type_set_offsets(allocator, t);
+		type_set_offsets(t);
 		if (gb_is_between(index, 0, t->Struct.fields.count-1)) {
 			return t->Struct.offsets[index];
 		}
 	} else if (t->kind == Type_Tuple) {
-		type_set_offsets(allocator, t);
+		type_set_offsets(t);
 		if (gb_is_between(index, 0, t->Tuple.variables.count-1)) {
 			return t->Tuple.offsets[index];
 		}
@@ -2242,7 +2246,7 @@ i64 type_offset_of(gbAllocator allocator, Type *t, i32 index) {
 		case 3: return 3*build_context.word_size; // allocator
 		}
 	} else if (t->kind == Type_Union) {
-		/* i64 s = */ type_size_of(allocator, t);
+		/* i64 s = */ type_size_of(t);
 		switch (index) {
 		case -1: return align_formula(t->Union.variant_block_size, build_context.word_size); // __type_info
 		}
@@ -2251,7 +2255,7 @@ i64 type_offset_of(gbAllocator allocator, Type *t, i32 index) {
 }
 
 
-i64 type_offset_of_from_selection(gbAllocator allocator, Type *type, Selection sel) {
+i64 type_offset_of_from_selection(Type *type, Selection sel) {
 	GB_ASSERT(sel.indirect == false);
 
 	Type *t = type;
@@ -2259,7 +2263,7 @@ i64 type_offset_of_from_selection(gbAllocator allocator, Type *type, Selection s
 	for_array(i, sel.index) {
 		i32 index = sel.index[i];
 		t = base_type(t);
-		offset += type_offset_of(allocator, t, index);
+		offset += type_offset_of(t, index);
 		if (t->kind == Type_Struct && !t->Struct.is_raw_union) {
 			t = t->Struct.fields[index]->type;
 		} else {