Use templated `Array` with bounds checking

1 files changed, 103 insertions, 105 deletions

diff --git a/src/check_expr.cpp b/src/check_expr.cpp
index 86d0541af..55670f7e5 100644
--- a/src/check_expr.cpp
+++ b/src/check_expr.cpp
@@ -53,7 +53,7 @@ void check_scope_decls(Checker *c, AstNodeArray nodes, isize reserve_size) {
 	check_collect_entities(c, nodes, false);
 
 	for_array(i, s->elements.entries) {
-		Entity *e = s->elements.entries.e[i].value;
+		Entity *e = s->elements.entries[i].value;
 		switch (e->kind) {
 		case Entity_Constant:
 		case Entity_TypeName:
@@ -70,7 +70,7 @@ void check_scope_decls(Checker *c, AstNodeArray nodes, isize reserve_size) {
 	}
 
 	for_array(i, s->elements.entries) {
-		Entity *e = s->elements.entries.e[i].value;
+		Entity *e = s->elements.entries[i].value;
 		if (e->kind != Entity_Procedure) {
 			continue;
 		}
@@ -401,7 +401,7 @@ isize check_fields(Checker *c, AstNode *node, AstNodeArray decls,
 
 	isize field_index = 0;
 	for_array(decl_index, decls) {
-		AstNode *decl = decls.e[decl_index];
+		AstNode *decl = decls[decl_index];
 		if (decl->kind != AstNode_Field) {
 			continue;
 		}
@@ -412,13 +412,13 @@ isize check_fields(Checker *c, AstNode *node, AstNodeArray decls,
 
 		if (is_using) {
 			if (f->names.count > 1) {
-				error_node(f->names.e[0], "Cannot apply `using` to more than one of the same type");
+				error_node(f->names[0], "Cannot apply `using` to more than one of the same type");
 				is_using = false;
 			}
 		}
 
 		for_array(name_index, f->names) {
-			AstNode *name = f->names.e[name_index];
+			AstNode *name = f->names[name_index];
 			if (!ast_node_expect(name, AstNode_Ident)) {
 				continue;
 			}
@@ -454,15 +454,15 @@ isize check_fields(Checker *c, AstNode *node, AstNodeArray decls,
 			Type *t = base_type(type_deref(type));
 			if (!is_type_struct(t) && !is_type_raw_union(t) && !is_type_bit_field(t) &&
 			    f->names.count >= 1 &&
-			    f->names.e[0]->kind == AstNode_Ident) {
-				Token name_token = f->names.e[0]->Ident;
+			    f->names[0]->kind == AstNode_Ident) {
+				Token name_token = f->names[0]->Ident;
 				if (is_type_indexable(t)) {
 					bool ok = true;
 					for_array(emi, entity_map.entries) {
-						Entity *e = entity_map.entries.e[emi].value;
+						Entity *e = entity_map.entries[emi].value;
 						if (e->kind == Entity_Variable && e->flags & EntityFlag_Using) {
 							if (is_type_indexable(e->type)) {
-								if (e->identifier != f->names.e[0]) {
+								if (e->identifier != f->names[0]) {
 									ok = false;
 									using_index_expr = e;
 									break;
@@ -545,7 +545,7 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node) {
 
 	isize field_count = 0;
 	for_array(field_index, st->fields) {
-	AstNode *field = st->fields.e[field_index];
+	AstNode *field = st->fields[field_index];
 		switch (field->kind) {
 		case_ast_node(f, Field, field);
 			field_count += f->names.count;
@@ -641,7 +641,7 @@ void check_union_type(Checker *c, Type *union_type, AstNode *node) {
 	isize variant_count = ut->variants.count+1;
 	isize field_count = 0;
 	for_array(i, ut->fields) {
-		AstNode *field = ut->fields.e[i];
+		AstNode *field = ut->fields[i];
 		if (field->kind == AstNode_Field) {
 			ast_node(f, Field, field);
 			field_count += f->names.count;
@@ -680,7 +680,7 @@ void check_union_type(Checker *c, Type *union_type, AstNode *node) {
 	}
 
 	for_array(i, ut->variants) {
-		AstNode *variant = ut->variants.e[i];
+		AstNode *variant = ut->variants[i];
 		if (variant->kind != AstNode_UnionField) {
 			continue;
 		}
@@ -694,12 +694,12 @@ void check_union_type(Checker *c, Type *union_type, AstNode *node) {
 			// NOTE(bill): Copy the contents for the common fields for now
 			AstNodeArray list = {};
 			array_init_count(&list, c->allocator, ut->fields.count+fl->list.count);
-			gb_memmove_array(list.e, ut->fields.e, ut->fields.count);
-			gb_memmove_array(list.e+ut->fields.count, fl->list.e, fl->list.count);
+			gb_memmove_array(list.data, ut->fields.data, ut->fields.count);
+			gb_memmove_array(list.data+ut->fields.count, fl->list.data, fl->list.count);
 
 			isize list_count = 0;
 			for_array(j, list) {
-				ast_node(f, Field, list.e[j]);
+				ast_node(f, Field, list[j]);
 				list_count += f->names.count;
 			}
 
@@ -760,7 +760,7 @@ void check_raw_union_type(Checker *c, Type *union_type, AstNode *node) {
 
 	isize field_count = 0;
 	for_array(field_index, ut->fields) {
-		AstNode *field = ut->fields.e[field_index];
+		AstNode *field = ut->fields[field_index];
 		switch (field->kind) {
 		case_ast_node(f, Field, field);
 			field_count += f->names.count;
@@ -817,7 +817,7 @@ void check_enum_type(Checker *c, Type *enum_type, Type *named_type, AstNode *nod
 	ExactValue max_value = exact_value_i64(0);
 
 	for_array(i, et->fields) {
-		AstNode *field = et->fields.e[i];
+		AstNode *field = et->fields[i];
 		AstNode *ident = NULL;
 		AstNode *init = NULL;
 		if (field->kind == AstNode_FieldValue) {
@@ -932,7 +932,7 @@ void check_bit_field_type(Checker *c, Type *bit_field_type, Type *named_type, As
 
 	u32 curr_offset = 0;
 	for_array(i, bft->fields) {
-		AstNode *field = bft->fields.e[i];
+		AstNode *field = bft->fields[i];
 		GB_ASSERT(field->kind == AstNode_FieldValue);
 		AstNode *ident = field->FieldValue.field;
 		AstNode *value = field->FieldValue.value;
@@ -1041,7 +1041,7 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari
 
 	isize variable_count = 0;
 	for_array(i, params) {
-		AstNode *field = params.e[i];
+		AstNode *field = params[i];
 		if (ast_node_expect(field, AstNode_Field)) {
 			ast_node(f, Field, field);
 			variable_count += gb_max(f->names.count, 1);
@@ -1052,10 +1052,10 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari
 	Entity **variables = gb_alloc_array(c->allocator, Entity *, variable_count);
 	isize variable_index = 0;
 	for_array(i, params) {
-		if (params.e[i]->kind != AstNode_Field) {
+		if (params[i]->kind != AstNode_Field) {
 			continue;
 		}
-		ast_node(p, Field, params.e[i]);
+		ast_node(p, Field, params[i]);
 		AstNode *type_expr = p->type;
 		if (type_expr) {
 			if (type_expr->kind == AstNode_Ellipsis) {
@@ -1063,20 +1063,20 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari
 				if (i+1 == params.count) {
 					is_variadic = true;
 				} else {
-					error_node(params.e[i], "Invalid AST: Invalid variadic parameter");
+					error_node(params[i], "Invalid AST: Invalid variadic parameter");
 				}
 			}
 
 			Type *type = check_type(c, type_expr);
 			if (p->flags&FieldFlag_no_alias) {
 				if (!is_type_pointer(type)) {
-					error_node(params.e[i], "`no_alias` can only be applied to fields of pointer type");
+					error_node(params[i], "`no_alias` can only be applied to fields of pointer type");
 					p->flags &= ~FieldFlag_no_alias; // Remove the flag
 				}
 			}
 
 			for_array(j, p->names) {
-				AstNode *name = p->names.e[j];
+				AstNode *name = p->names[j];
 				if (ast_node_expect(name, AstNode_Ident)) {
 					Entity *param = make_entity_param(c->allocator, scope, name->Ident, type,
 					                                  (p->flags&FieldFlag_using) != 0, (p->flags&FieldFlag_immutable) != 0);
@@ -1127,7 +1127,7 @@ Type *check_get_results(Checker *c, Scope *scope, AstNode *_results) {
 
 	isize variable_count = 0;
 	for_array(i, results) {
-		AstNode *field = results.e[i];
+		AstNode *field = results[i];
 		if (ast_node_expect(field, AstNode_Field)) {
 			ast_node(f, Field, field);
 			variable_count += gb_max(f->names.count, 1);
@@ -1137,7 +1137,7 @@ Type *check_get_results(Checker *c, Scope *scope, AstNode *_results) {
 	Entity **variables = gb_alloc_array(c->allocator, Entity *, variable_count);
 	isize variable_index = 0;
 	for_array(i, results) {
-		ast_node(field, Field, results.e[i]);
+		ast_node(field, Field, results[i]);
 		Type *type = check_type(c, field->type);
 		if (field->names.count == 0) {
 			Token token = ast_node_token(field->type);
@@ -1149,7 +1149,7 @@ Type *check_get_results(Checker *c, Scope *scope, AstNode *_results) {
 				Token token = ast_node_token(field->type);
 				token.string = str_lit("");
 
-				AstNode *name = field->names.e[j];
+				AstNode *name = field->names[j];
 				if (name->kind != AstNode_Ident) {
 					error_node(name, "Expected an identifer for as the field name");
 				} else {
@@ -3551,7 +3551,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		// NOTE(bill): The first arg may be a Type, this will be checked case by case
 		break;
 	default:
-		check_multi_expr(c, operand, ce->args.e[0]);
+		check_multi_expr(c, operand, ce->args[0]);
 	}
 
 	switch (id) {
@@ -3609,10 +3609,10 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 	case BuiltinProc_new: {
 		// new :: proc(Type) -> ^Type
 		Operand op = {};
-		check_expr_or_type(c, &op, ce->args.e[0]);
+		check_expr_or_type(c, &op, ce->args[0]);
 		Type *type = op.type;
 		if ((op.mode != Addressing_Type && type == NULL) || type == t_invalid) {
-			error_node(ce->args.e[0], "Expected a type for `new`");
+			error_node(ce->args[0], "Expected a type for `new`");
 			return false;
 		}
 		operand->mode = Addressing_Value;
@@ -3623,16 +3623,16 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		// new_slice :: proc(Type, len: int) -> []Type
 		// new_slice :: proc(Type, len, cap: int) -> []Type
 		Operand op = {};
-		check_expr_or_type(c, &op, ce->args.e[0]);
+		check_expr_or_type(c, &op, ce->args[0]);
 		Type *type = op.type;
 		if ((op.mode != Addressing_Type && type == NULL) || type == t_invalid) {
-			error_node(ce->args.e[0], "Expected a type for `new_slice`");
+			error_node(ce->args[0], "Expected a type for `new_slice`");
 			return false;
 		}
 
 		isize arg_count = ce->args.count;
 		if (arg_count < 2 || 3 < arg_count) {
-			error_node(ce->args.e[0], "`new_slice` expects 2 or 3 arguments, found %td", arg_count);
+			error_node(ce->args[0], "`new_slice` expects 2 or 3 arguments, found %td", arg_count);
 			// NOTE(bill): Return the correct type to reduce errors
 		} else {
 			// If any are constant
@@ -3640,7 +3640,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 			isize size_count = 0;
 			for (isize i = 1; i < arg_count; i++) {
 				i64 val = 0;
-				bool ok = check_index_value(c, ce->args.e[i], -1, &val);
+				bool ok = check_index_value(c, ce->args[i], -1, &val);
 				if (ok && val >= 0) {
 					GB_ASSERT(size_count < gb_count_of(sizes));
 					sizes[size_count++] = val;
@@ -3648,7 +3648,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 			}
 
 			if (size_count == 2 && sizes[0] > sizes[1]) {
-				error_node(ce->args.e[1], "`new_slice` count and capacity are swapped");
+				error_node(ce->args[1], "`new_slice` count and capacity are swapped");
 				// No need quit
 			}
 		}
@@ -3661,10 +3661,10 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		// make :: proc(Type, len: int) -> Type
 		// make :: proc(Type, len, cap: int) -> Type
 		Operand op = {};
-		check_expr_or_type(c, &op, ce->args.e[0]);
+		check_expr_or_type(c, &op, ce->args[0]);
 		Type *type = op.type;
 		if ((op.mode != Addressing_Type && type == NULL) || type == t_invalid) {
-			error_node(ce->args.e[0], "Expected a type for `make`");
+			error_node(ce->args[0], "Expected a type for `make`");
 			return false;
 		}
 
@@ -3688,7 +3688,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 
 		isize arg_count = ce->args.count;
 		if (arg_count < min_args || max_args < arg_count) {
-			error_node(ce->args.e[0], "`make` expects %td or %d argument, found %td", min_args, max_args, arg_count);
+			error_node(ce->args[0], "`make` expects %td or %d argument, found %td", min_args, max_args, arg_count);
 			return false;
 		}
 
@@ -3697,7 +3697,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		isize size_count = 0;
 		for (isize i = 1; i < arg_count; i++) {
 			i64 val = 0;
-			bool ok = check_index_value(c, false, ce->args.e[i], -1, &val);
+			bool ok = check_index_value(c, false, ce->args[i], -1, &val);
 			if (ok && val >= 0) {
 				GB_ASSERT(size_count < gb_count_of(sizes));
 				sizes[size_count++] = val;
@@ -3705,7 +3705,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		}
 
 		if (size_count == 2 && sizes[0] > sizes[1]) {
-			error_node(ce->args.e[1], "`make` count and capacity are swapped");
+			error_node(ce->args[1], "`make` count and capacity are swapped");
 			// No need quit
 		}
 
@@ -3755,7 +3755,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 			return false;
 		}
 
-		AstNode *capacity = ce->args.e[1];
+		AstNode *capacity = ce->args[1];
 		Operand op = {};
 		check_expr(c, &op, capacity);
 		if (op.mode == Addressing_Invalid) {
@@ -3846,7 +3846,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 
 		Type *key = base_type(type)->Map.key;
 		Operand x = {Addressing_Invalid};
-		AstNode *key_node = ce->args.e[1];
+		AstNode *key_node = ce->args[1];
 		Operand op = {};
 		check_expr(c, &op, key_node);
 		if (op.mode == Addressing_Invalid) {
@@ -3868,9 +3868,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 
 	case BuiltinProc_size_of: {
 		// size_of :: proc(Type) -> untyped int
-		Type *type = check_type(c, ce->args.e[0]);
+		Type *type = check_type(c, ce->args[0]);
 		if (type == NULL || type == t_invalid) {
-			error_node(ce->args.e[0], "Expected a type for `size_of`");
+			error_node(ce->args[0], "Expected a type for `size_of`");
 			return false;
 		}
 
@@ -3894,9 +3894,9 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 
 	case BuiltinProc_align_of: {
 		// align_of :: proc(Type) -> untyped int
-		Type *type = check_type(c, ce->args.e[0]);
+		Type *type = check_type(c, ce->args[0]);
 		if (type == NULL || type == t_invalid) {
-			error_node(ce->args.e[0], "Expected a type for `align_of`");
+			error_node(ce->args[0], "Expected a type for `align_of`");
 			return false;
 		}
 		operand->mode = Addressing_Constant;
@@ -3919,14 +3919,14 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 	case BuiltinProc_offset_of: {
 		// offset_of :: proc(Type, field) -> untyped int
 		Operand op = {};
-		Type *bt = check_type(c, ce->args.e[0]);
+		Type *bt = check_type(c, ce->args[0]);
 		Type *type = base_type(bt);
 		if (type == NULL || type == t_invalid) {
-			error_node(ce->args.e[0], "Expected a type for `offset_of`");
+			error_node(ce->args[0], "Expected a type for `offset_of`");
 			return false;
 		}
 
-		AstNode *field_arg = unparen_expr(ce->args.e[1]);
+		AstNode *field_arg = unparen_expr(ce->args[1]);
 		if (field_arg == NULL ||
 		    field_arg->kind != AstNode_Ident) {
 			error_node(field_arg, "Expected an identifier for field argument");
@@ -3942,14 +3942,14 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		Selection sel = lookup_field(c->allocator, type, arg->string, operand->mode == Addressing_Type);
 		if (sel.entity == NULL) {
 			gbString type_str = type_to_string(bt);
-			error_node(ce->args.e[0],
+			error_node(ce->args[0],
 			      "`%s` has no field named `%.*s`", type_str, LIT(arg->string));
 			gb_string_free(type_str);
 			return false;
 		}
 		if (sel.indirect) {
 			gbString type_str = type_to_string(bt);
-			error_node(ce->args.e[0],
+			error_node(ce->args[0],
 			      "Field `%.*s` is embedded via a pointer in `%s`", LIT(arg->string), type_str);
 			gb_string_free(type_str);
 			return false;
@@ -3962,7 +3962,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 
 	case BuiltinProc_offset_of_val: {
 		// offset_of_val :: proc(val: expression) -> untyped int
-		AstNode *arg = unparen_expr(ce->args.e[0]);
+		AstNode *arg = unparen_expr(ce->args[0]);
 		if (arg->kind != AstNode_SelectorExpr) {
 			gbString str = expr_to_string(arg);
 			error_node(arg, "`%s` is not a selector expression", str);
@@ -3997,7 +3997,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		}
 		if (sel.indirect) {
 			gbString type_str = type_to_string(type);
-			error_node(ce->args.e[0],
+			error_node(ce->args[0],
 			      "Field `%.*s` is embedded via a pointer in `%s`", LIT(i->string), type_str);
 			gb_string_free(type_str);
 			return false;
@@ -4031,7 +4031,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 
 		// NOTE(bill): The type information may not be setup yet
 		init_preload(c);
-		AstNode *expr = ce->args.e[0];
+		AstNode *expr = ce->args[0];
 		Type *type = check_type(c, expr);
 		if (type == NULL || type == t_invalid) {
 			error_node(expr, "Invalid argument to `type_info`");
@@ -4052,7 +4052,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 
 		// NOTE(bill): The type information may not be setup yet
 		init_preload(c);
-		AstNode *expr = ce->args.e[0];
+		AstNode *expr = ce->args[0];
 		check_assignment(c, operand, NULL, str_lit("argument of `type_info_of_val`"));
 		if (operand->mode == Addressing_Invalid || operand->mode == Addressing_Builtin)
 			return false;
@@ -4066,13 +4066,13 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		// compile_assert :: proc(cond: bool) -> bool
 
 		if (!is_type_boolean(operand->type) && operand->mode != Addressing_Constant) {
-			gbString str = expr_to_string(ce->args.e[0]);
+			gbString str = expr_to_string(ce->args[0]);
 			error_node(call, "`%s` is not a constant boolean", str);
 			gb_string_free(str);
 			return false;
 		}
 		if (!operand->value.value_bool) {
-			gbString str = expr_to_string(ce->args.e[0]);
+			gbString str = expr_to_string(ce->args[0]);
 			error_node(call, "Compile time assertion: `%s`", str);
 			gb_string_free(str);
 		}
@@ -4085,7 +4085,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		// assert :: proc(cond: bool) -> bool
 
 		if (!is_type_boolean(operand->type)) {
-			gbString str = expr_to_string(ce->args.e[0]);
+			gbString str = expr_to_string(ce->args[0]);
 			error_node(call, "`%s` is not a boolean", str);
 			gb_string_free(str);
 			return false;
@@ -4099,7 +4099,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		// panic :: proc(msg: string)
 
 		if (!is_type_string(operand->type)) {
-			gbString str = expr_to_string(ce->args.e[0]);
+			gbString str = expr_to_string(ce->args[0]);
 			error_node(call, "`%s` is not a string", str);
 			gb_string_free(str);
 			return false;
@@ -4117,7 +4117,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 			dest_type = d->Slice.elem;
 		}
 		Operand op = {};
-		check_expr(c, &op, ce->args.e[1]);
+		check_expr(c, &op, ce->args[1]);
 		if (op.mode == Addressing_Invalid) {
 			return false;
 		}
@@ -4132,8 +4132,8 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		}
 
 		if (!are_types_identical(dest_type, src_type)) {
-			gbString d_arg = expr_to_string(ce->args.e[0]);
-			gbString s_arg = expr_to_string(ce->args.e[1]);
+			gbString d_arg = expr_to_string(ce->args[0]);
+			gbString s_arg = expr_to_string(ce->args[1]);
 			gbString d_str = type_to_string(dest_type);
 			gbString s_str = type_to_string(src_type);
 			error_node(call,
@@ -4169,7 +4169,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 			if (i == 0) {
 				continue;
 			}
-			AstNode *arg = ce->args.e[i];
+			AstNode *arg = ce->args[i];
 			Operand op = {};
 			check_expr(c, &op, arg);
 			if (op.mode == Addressing_Invalid) {
@@ -4213,7 +4213,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		operand->type = t_invalid;
 		operand->mode = Addressing_Invalid;
 
-		check_expr(c, &y, ce->args.e[1]);
+		check_expr(c, &y, ce->args[1]);
 		if (y.mode == Addressing_Invalid) {
 			return false;
 		}
@@ -4348,7 +4348,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 
 		isize arg_count = ce->args.count;
 		if (arg_count < 2 || 3 < arg_count) {
-			error_node(ce->args.e[0], "`slice_ptr` expects 2 or 3 arguments, found %td", arg_count);
+			error_node(ce->args[0], "`slice_ptr` expects 2 or 3 arguments, found %td", arg_count);
 			// NOTE(bill): Return the correct type to reduce errors
 		} else {
 			// If any are constant
@@ -4356,7 +4356,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 			isize size_count = 0;
 			for (isize i = 1; i < arg_count; i++) {
 				i64 val = 0;
-				bool ok = check_index_value(c, false, ce->args.e[i], -1, &val);
+				bool ok = check_index_value(c, false, ce->args[i], -1, &val);
 				if (ok && val >= 0) {
 					GB_ASSERT(size_count < gb_count_of(sizes));
 					sizes[size_count++] = val;
@@ -4364,7 +4364,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 			}
 
 			if (size_count == 2 && sizes[0] > sizes[1]) {
-				error_node(ce->args.e[1], "`slice_ptr` count and capacity are swapped");
+				error_node(ce->args[1], "`slice_ptr` count and capacity are swapped");
 				// No need quit
 			}
 		}
@@ -4396,7 +4396,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 			return false;
 		}
 
-		AstNode *other_arg = ce->args.e[1];
+		AstNode *other_arg = ce->args[1];
 		Operand a = *operand;
 		Operand b = {};
 		check_expr(c, &b, other_arg);
@@ -4464,7 +4464,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 			return false;
 		}
 
-		AstNode *other_arg = ce->args.e[1];
+		AstNode *other_arg = ce->args[1];
 		Operand a = *operand;
 		Operand b = {};
 		check_expr(c, &b, other_arg);
@@ -4566,8 +4566,8 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 			return false;
 		}
 
-		AstNode *min_arg = ce->args.e[1];
-		AstNode *max_arg = ce->args.e[2];
+		AstNode *min_arg = ce->args[1];
+		AstNode *max_arg = ce->args[2];
 		Operand x = *operand;
 		Operand y = {};
 		Operand z = {};
@@ -4646,13 +4646,13 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 
 	case BuiltinProc_transmute: {
 		Operand op = {};
-		check_expr_or_type(c, &op, ce->args.e[0]);
+		check_expr_or_type(c, &op, ce->args[0]);
 		Type *t = op.type;
 		if ((op.mode != Addressing_Type && t == NULL) || t == t_invalid) {
-			error_node(ce->args.e[0], "Expected a type for `transmute`");
+			error_node(ce->args[0], "Expected a type for `transmute`");
 			return false;
 		}
-		AstNode *expr = ce->args.e[1];
+		AstNode *expr = ce->args[1];
 		Operand *o = operand;
 		check_expr(c, o, expr);
 		if (o->mode == Addressing_Invalid) {
@@ -4834,13 +4834,11 @@ int valid_proc_and_score_cmp(void const *a, void const *b) {
 	return sj < si ? -1 : sj > si;
 }
 
-typedef Array(Operand) ArrayOperand;
-
-bool check_unpack_arguments(Checker *c, isize lhs_count, ArrayOperand *operands, AstNodeArray rhs, bool allow_ok) {
+bool check_unpack_arguments(Checker *c, isize lhs_count, Array<Operand> *operands, AstNodeArray rhs, bool allow_ok) {
 	bool optional_ok = false;
 	for_array(i, rhs) {
 		Operand o = {};
-		check_multi_expr(c, &o, rhs.e[i]);
+		check_multi_expr(c, &o, rhs[i]);
 
 		if (o.type == NULL || o.type->kind != Type_Tuple) {
 			if (allow_ok && lhs_count == 2 && rhs.count == 1 &&
@@ -4877,8 +4875,8 @@ Type *check_call_arguments(Checker *c, Operand *operand, Type *proc_type, AstNod
 
 	ast_node(ce, CallExpr, call);
 
-	ArrayOperand operands;
-	array_init_reserve(&operands, heap_allocator(), 2*ce->args.count);
+	Array<Operand> operands;
+	array_init(&operands, heap_allocator(), 2*ce->args.count);
 	check_unpack_arguments(c, -1, &operands, ce->args, false);
 
 	if (operand->mode == Addressing_Overload) {
@@ -4905,7 +4903,7 @@ Type *check_call_arguments(Checker *c, Operand *operand, Type *proc_type, AstNod
 			Type *proc_type = base_type(p->type);
 			if (proc_type != NULL && is_type_proc(proc_type)) {
 				i64 score = 0;
-				CallArgumentError err = check_call_arguments_internal(c, call, proc_type, operands.e, operands.count, CallArgumentMode_NoErrors, &score);
+				CallArgumentError err = check_call_arguments_internal(c, call, proc_type, operands.data, operands.count, CallArgumentMode_NoErrors, &score);
 				if (err == CallArgumentError_None) {
 					valids[valid_count].index = i;
 					valids[valid_count].score = score;
@@ -4950,14 +4948,14 @@ Type *check_call_arguments(Checker *c, Operand *operand, Type *proc_type, AstNod
 			add_entity_use(c, expr, e);
 			proc_type = e->type;
 			i64 score = 0;
-			CallArgumentError err = check_call_arguments_internal(c, call, proc_type, operands.e, operands.count, CallArgumentMode_ShowErrors, &score);
+			CallArgumentError err = check_call_arguments_internal(c, call, proc_type, operands.data, operands.count, CallArgumentMode_ShowErrors, &score);
 		}
 
 		gb_free(heap_allocator(), valids);
 		gb_free(heap_allocator(), procs);
 	} else {
 		i64 score = 0;
-		CallArgumentError err = check_call_arguments_internal(c, call, proc_type, operands.e, operands.count, CallArgumentMode_ShowErrors, &score);
+		CallArgumentError err = check_call_arguments_internal(c, call, proc_type, operands.data, operands.count, CallArgumentMode_ShowErrors, &score);
 		array_free(&operands);
 	}
 	return proc_type;
@@ -4994,7 +4992,7 @@ ExprKind check_call_expr(Checker *c, Operand *operand, AstNode *call) {
 
 	if (operand->mode == Addressing_Invalid) {
 		for_array(i, ce->args) {
-			check_expr_base(c, operand, ce->args.e[i], NULL);
+			check_expr_base(c, operand, ce->args[i], NULL);
 		}
 		operand->mode = Addressing_Invalid;
 		operand->expr = call;
@@ -5010,7 +5008,7 @@ ExprKind check_call_expr(Checker *c, Operand *operand, AstNode *call) {
 		case 0:  error_node(call, "Missing argument in convertion to `%s`", str);   break;
 		default: error_node(call, "Too many arguments in convertion to `%s`", str); break;
 		case 1:
-			check_expr(c, operand, ce->args.e[0]);
+			check_expr(c, operand, ce->args[0]);
 			if (operand->mode != Addressing_Invalid) {
 				check_cast(c, operand, t);
 			}
@@ -5388,11 +5386,11 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 			}
 			{ // Checker values
 				isize field_count = t->Record.field_count;
-				if (cl->elems.e[0]->kind == AstNode_FieldValue) {
+				if (cl->elems[0]->kind == AstNode_FieldValue) {
 					bool *fields_visited = gb_alloc_array(c->allocator, bool, field_count);
 
 					for_array(i, cl->elems) {
-						AstNode *elem = cl->elems.e[i];
+						AstNode *elem = cl->elems[i];
 						if (elem->kind != AstNode_FieldValue) {
 							error_node(elem, "Mixture of `field = value` and value elements in a structure literal is not allowed");
 							continue;
@@ -5423,15 +5421,15 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 							continue;
 						}
 
-						Entity *field = t->Record.fields[sel.index.e[0]];
+						Entity *field = t->Record.fields[sel.index[0]];
 						add_entity_use(c, fv->field, field);
 
-						if (fields_visited[sel.index.e[0]]) {
+						if (fields_visited[sel.index[0]]) {
 							error_node(elem, "Duplicate field `%.*s` in structure literal", LIT(name));
 							continue;
 						}
 
-						fields_visited[sel.index.e[0]] = true;
+						fields_visited[sel.index[0]] = true;
 						check_expr(c, o, fv->value);
 
 						if (is_type_any(field->type) || is_type_union(field->type) || is_type_raw_union(field->type)) {
@@ -5455,7 +5453,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 					}
 
 					for_array(index, cl->elems) {
-						AstNode *elem = cl->elems.e[index];
+						AstNode *elem = cl->elems[index];
 						if (elem->kind == AstNode_FieldValue) {
 							error_node(elem, "Mixture of `field = value` and value elements in a structure literal is not allowed");
 							continue;
@@ -5533,8 +5531,8 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 			}
 
 			for (; index < elem_count; index++) {
-				GB_ASSERT(cl->elems.e != NULL);
-				AstNode *e = cl->elems.e[index];
+				GB_ASSERT(cl->elems.data != NULL);
+				AstNode *e = cl->elems[index];
 				if (e == NULL) {
 					error_node(node, "Invalid literal element");
 					continue;
@@ -5563,7 +5561,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 
 			if (t->kind == Type_Vector) {
 				if (t->Vector.count > 1 && gb_is_between(index, 2, t->Vector.count-1)) {
-					error_node(cl->elems.e[0], "Expected either 1 (broadcast) or %td elements in vector literal, got %td", t->Vector.count, index);
+					error_node(cl->elems[0], "Expected either 1 (broadcast) or %td elements in vector literal, got %td", t->Vector.count, index);
 				}
 			}
 
@@ -5585,11 +5583,11 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 			{ // Checker values
 				Type *field_types[2] = {t_rawptr, t_type_info_ptr};
 				isize field_count = 2;
-				if (cl->elems.e[0]->kind == AstNode_FieldValue) {
+				if (cl->elems[0]->kind == AstNode_FieldValue) {
 					bool fields_visited[2] = {};
 
 					for_array(i, cl->elems) {
-						AstNode *elem = cl->elems.e[i];
+						AstNode *elem = cl->elems[i];
 						if (elem->kind != AstNode_FieldValue) {
 							error_node(elem, "Mixture of `field = value` and value elements in a `any` literal is not allowed");
 							continue;
@@ -5609,7 +5607,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 							continue;
 						}
 
-						isize index = sel.index.e[0];
+						isize index = sel.index[0];
 
 						if (fields_visited[index]) {
 							error_node(elem, "Duplicate field `%.*s` in `any` literal", LIT(name));
@@ -5626,7 +5624,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 					}
 				} else {
 					for_array(index, cl->elems) {
-						AstNode *elem = cl->elems.e[index];
+						AstNode *elem = cl->elems[index];
 						if (elem->kind == AstNode_FieldValue) {
 							error_node(elem, "Mixture of `field = value` and value elements in a `any` literal is not allowed");
 							continue;
@@ -5658,7 +5656,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
 			is_constant = false;
 			{ // Checker values
 				for_array(i, cl->elems) {
-					AstNode *elem = cl->elems.e[i];
+					AstNode *elem = cl->elems[i];
 					if (elem->kind != AstNode_FieldValue) {
 						error_node(elem, "Only `field = value` elements are allowed in a map literal");
 						continue;
@@ -6146,7 +6144,7 @@ gbString write_record_fields_to_string(gbString str, AstNodeArray params) {
 		if (i > 0) {
 			str = gb_string_appendc(str, ", ");
 		}
-		str = write_expr_to_string(str, params.e[i]);
+		str = write_expr_to_string(str, params[i]);
 	}
 	return str;
 }
@@ -6200,7 +6198,7 @@ gbString write_expr_to_string(gbString str, AstNode *node) {
 			if (i > 0) {
 				str = gb_string_appendc(str, ", ");
 			}
-			str = write_expr_to_string(str, cl->elems.e[i]);
+			str = write_expr_to_string(str, cl->elems[i]);
 		}
 		str = gb_string_appendc(str, "}");
 	case_end;
@@ -6321,7 +6319,7 @@ gbString write_expr_to_string(gbString str, AstNode *node) {
 		}
 
 		for_array(i, f->names) {
-			AstNode *name = f->names.e[i];
+			AstNode *name = f->names[i];
 			if (i > 0) {
 				str = gb_string_appendc(str, ", ");
 			}
@@ -6341,7 +6339,7 @@ gbString write_expr_to_string(gbString str, AstNode *node) {
 			if (i > 0) {
 				str = gb_string_appendc(str, ", ");
 			}
-			str = write_expr_to_string(str, f->list.e[i]);
+			str = write_expr_to_string(str, f->list[i]);
 		}
 	case_end;
 
@@ -6357,7 +6355,7 @@ gbString write_expr_to_string(gbString str, AstNode *node) {
 		str = gb_string_appendc(str, "(");
 
 		for_array(i, ce->args) {
-			AstNode *arg = ce->args.e[i];
+			AstNode *arg = ce->args[i];
 			if (i > 0) {
 				str = gb_string_appendc(str, ", ");
 			}
@@ -6406,7 +6404,7 @@ gbString write_expr_to_string(gbString str, AstNode *node) {
 			if (i > 0) {
 				str = gb_string_appendc(str, ", ");
 			}
-			str = write_expr_to_string(str, et->fields.e[i]);
+			str = write_expr_to_string(str, et->fields[i]);
 		}
 		str = gb_string_appendc(str, "}");
 	case_end;