Fix defer ir bug

src/check_expr.cpp

@@ -2040,7 +2040,7 @@ void check_binary_expr(CheckerContext *c, Operand *x, Ast *node, bool use_lhs_as
 			add_package_dependency(c, "runtime", "__dynamic_map_get");
 		} else if (is_type_bit_set(y->type)) {
 			Type *yt = base_type(y->type);
-			check_assignment(c, x, yt->BitSet.base_type, str_lit("bit_set 'in'"));
+			check_assignment(c, x, yt->BitSet.base, str_lit("bit_set 'in'"));
 		} else {
 			gbString t = type_to_string(y->type);
 			error(x->expr, "expected either a map or bitset for 'in', got %s", t);
@@ -5527,7 +5527,7 @@ ExprKind check_expr_base_internal(CheckerContext *c, Operand *o, Ast *node, Type
 			if (cl->elems.count == 0) {
 				break; // NOTE(bill): No need to init
 			}
-			Type *et = base_type(t->BitSet.base_type);
+			Type *et = base_type(t->BitSet.base);
 			isize field_count = 0;
 			if (et->kind == Type_Enum) {
 				field_count = et->Enum.fields.count;
@@ -5551,7 +5551,7 @@ ExprKind check_expr_base_internal(CheckerContext *c, Operand *o, Ast *node, Type
 						is_constant = o->mode == Addressing_Constant;
 					}
 
-					check_assignment(c, o, t->BitSet.base_type, str_lit("bit_set literal"));
+					check_assignment(c, o, t->BitSet.base, str_lit("bit_set literal"));
 				}
 			}
 			break;
@@ -6293,7 +6293,7 @@ gbString write_expr_to_string(gbString str, Ast *node) {
 
 	case_ast_node(bs, BitSetType, node);
 		str = gb_string_appendc(str, "bit_set[");
-		str = write_expr_to_string(str, bs->base_type);
+		str = write_expr_to_string(str, bs->base);
 		str = gb_string_appendc(str, "]");
 	case_end;
 

src/check_type.cpp

@@ -502,8 +502,8 @@ void check_enum_type(CheckerContext *ctx, Type *enum_type, Type *named_type, Ast
 		base_type = check_type(ctx, et->base_type);
 	}
 
-	if (base_type == nullptr || !(is_type_integer(base_type) || is_type_float(base_type))) {
-		error(node, "Base type for enumeration must be numeric");
+	if (base_type == nullptr || !is_type_integer(base_type)) {
+		error(node, "Base type for enumeration must be an integer");
 		return;
 	}
 	if (is_type_enum(base_type)) {
@@ -685,16 +685,16 @@ void check_bit_set_type(CheckerContext *ctx, Type *type, Ast *node) {
 	ast_node(bs, BitSetType, node);
 	GB_ASSERT(type->kind == Type_BitSet);
 
-	Type *bt = check_type_expr(ctx, bs->base_type, nullptr);
+	Type *bt = check_type_expr(ctx, bs->base, nullptr);
 
-	type->BitSet.base_type = bt;
+	type->BitSet.base = bt;
 	if (!is_type_enum(bt)) {
-		error(bs->base_type, "Expected an enum type for a bit_set");
+		error(bs->base, "Expected an enum type for a bit_set");
 	} else {
 		Type *et = base_type(bt);
 		GB_ASSERT(et->kind == Type_Enum);
 		if (!is_type_integer(et->Enum.base_type)) {
-			error(bs->base_type, "Enum type for bit_set must be an integer");
+			error(bs->base, "Enum type for bit_set must be an integer");
 			return;
 		}
 		i64 min_value = 0;
@@ -713,8 +713,10 @@ void check_bit_set_type(CheckerContext *ctx, Type *type, Ast *node) {
 			max_value = gb_max(max_value, x);
 		}
 
+		GB_ASSERT(min_value <= max_value);
+
 		if (max_value - min_value > 64) {
-			error(bs->base_type, "bit_set range is greater than 64 bits");
+			error(bs->base, "bit_set range is greater than 64 bits");
 		}
 
 		type->BitSet.min = min_value;

src/checker.cpp

@@ -1044,7 +1044,7 @@ void add_type_info_type(CheckerContext *c, Type *t) {
 		break;
 
 	case Type_BitSet:
-		add_type_info_type(c, bt->BitSet.base_type);
+		add_type_info_type(c, bt->BitSet.base);
 		break;
 
 	case Type_Union:

src/ir.cpp

@@ -1758,8 +1758,7 @@ void ir_emit_defer_stmts(irProcedure *proc, irDeferExitKind kind, irBlock *block
 	isize i = count;
 	while (i --> 0) {
 		irDefer d = proc->defer_stmts[i];
-		if (d.context_stack_count >= 0) {
-			GB_ASSERT(proc->context_stack.count >= d.context_stack_count);
+		if (proc->context_stack.count >= d.context_stack_count) {
 			proc->context_stack.count = d.context_stack_count;
 		}
 
@@ -4910,7 +4909,7 @@ irValue *ir_build_expr_internal(irProcedure *proc, Ast *expr) {
 				{
 					ir_emit_comment(proc, str_lit("bit_set in"));
 
-					Type *key_type = rt->BitSet.base_type;
+					Type *key_type = rt->BitSet.base;
 					GB_ASSERT(are_types_identical(ir_type(left), key_type));
 
 					Type *it = bit_set_to_int(rt);
@@ -5662,9 +5661,9 @@ irAddr ir_build_addr(irProcedure *proc, Ast *expr) {
 
 		Type *et = nullptr;
 		switch (bt->kind) {
-		case Type_Array:  et = bt->Array.elem;       break;
-		case Type_Slice:  et = bt->Slice.elem;       break;
-		case Type_BitSet: et = bt->BitSet.base_type; break;
+		case Type_Array:  et = bt->Array.elem;  break;
+		case Type_Slice:  et = bt->Slice.elem;  break;
+		case Type_BitSet: et = bt->BitSet.base; break;
 		}
 
 		String proc_name = {};
@@ -8117,7 +8116,7 @@ void ir_setup_type_info_data(irProcedure *proc) { // NOTE(bill): Setup type_info
 		case Type_BitSet:
 			ir_emit_comment(proc, str_lit("Type_Info_Bit_Set"));
 			tag = ir_emit_conv(proc, variant_ptr, t_type_info_bit_set_ptr);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), ir_get_type_info_ptr(proc, t->BitSet.base_type));
+			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), ir_get_type_info_ptr(proc, t->BitSet.base));
 			break;
 
 		}

src/parser.cpp

@@ -347,7 +347,7 @@ Ast *clone_ast(Ast *node) {
 		n->BitFieldType.align = clone_ast(n->BitFieldType.align);
 		break;
 	case Ast_BitSetType:
-		n->BitSetType.base_type = clone_ast(n->BitSetType.base_type);
+		n->BitSetType.base = clone_ast(n->BitSetType.base);
 		break;
 	case Ast_MapType:
 		n->MapType.count = clone_ast(n->MapType.count);
@@ -927,10 +927,10 @@ Ast *ast_bit_field_type(AstFile *f, Token token, Array<Ast *> fields, Ast *align
 	return result;
 }
 
-Ast *ast_bit_set_type(AstFile *f, Token token, Ast *base_type) {
+Ast *ast_bit_set_type(AstFile *f, Token token, Ast *base) {
 	Ast *result = alloc_ast_node(f, Ast_BitSetType);
 	result->BitSetType.token = token;
-	result->BitSetType.base_type = base_type;
+	result->BitSetType.base = base;
 	return result;
 }
 
@@ -1901,27 +1901,10 @@ Ast *parse_operand(AstFile *f, bool lhs) {
 	} break;
 
 	case Token_enum: {
-		// bool is_export = false;
 		Token token = expect_token(f, Token_enum);
 		Ast *base_type = nullptr;
 		if (f->curr_token.kind != Token_OpenBrace) {
-			if (f->curr_token.kind != Token_Hash) {
-				base_type = parse_type(f);
-			}
-			// while (allow_token(f, Token_Hash)) {
-			// 	Token tag = f->curr_token;
-			// 	if (!allow_token(f, Token_Ident) && !allow_token(f, Token_export)) {
-			// 		expect_token_after(f, Token_Ident, "#");
-			// 	}
-			// 	if (tag.string == "export") {
-			// 		if (is_export) {
-			// 			syntax_error(tag, "Duplicate enum tag '#%.*s'", LIT(tag.string));
-			// 		}
-			// 		is_export = true;
-			// 	} else {
-			// 		syntax_error(tag, "Invalid enum tag '#%.*s'", LIT(tag.string));
-			// 	}
-			// }
+			base_type = parse_type(f);
 		}
 		Token open = expect_token(f, Token_OpenBrace);
 
@@ -1978,11 +1961,11 @@ Ast *parse_operand(AstFile *f, bool lhs) {
 
 	case Token_bit_set: {
 		Token token = expect_token(f, Token_bit_set);
-		Token open = expect_token(f, Token_OpenBracket);
-		Ast *base_type = parse_type(f);
+		Token open  = expect_token(f, Token_OpenBracket);
+		Ast * base  = parse_type(f);
 		Token close = expect_token(f, Token_CloseBracket);
 
-		return ast_bit_set_type(f, token, base_type);
+		return ast_bit_set_type(f, token, base);
 	}
 
 	default: {

src/parser.hpp

@@ -483,7 +483,7 @@ AST_KIND(_TypeBegin, "", bool) \
 	}) \
 	AST_KIND(BitSetType, "bit set type", struct { \
 		Token token; \
-		Ast * base_type; \
+		Ast * base;  \
 	}) \
 	AST_KIND(MapType, "map type", struct { \
 		Token token; \

src/types.cpp

@@ -179,7 +179,7 @@ struct TypeStruct {
 		i64             custom_align;                     \
 	})                                                    \
 	TYPE_KIND(BitSet, struct {                            \
-		Type *base_type;                                  \
+		Type *base;                                       \
 		i64   min;                                        \
 		i64   max;                                        \
 	})                                                    \
@@ -1277,7 +1277,7 @@ bool are_types_identical(Type *x, Type *y) {
 
 	case Type_BitSet:
 		if (y->kind == Type_BitSet) {
-			return are_types_identical(x->BitSet.base_type, y->BitSet.base_type);
+			return are_types_identical(x->BitSet.base, y->BitSet.base);
 		}
 		break;
 
@@ -2616,8 +2616,8 @@ gbString write_type_to_string(gbString str, Type *type) {
 		break;
 
 	case Type_BitSet:
-		str = gb_string_appendc(str, "bit_field[");
-		str = write_type_to_string(str, type->BitSet.base_type);
+		str = gb_string_appendc(str, "bit_set[");
+		str = write_type_to_string(str, type->BitSet.base);
 		str = gb_string_appendc(str, "]");
 		break;
 	}