Implement new union intrinsics and add support for len/cap

1 files changed, 138 insertions, 1 deletions

diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp
index 49095a7a8..8fae04b6e 100644
--- a/src/check_builtin.cpp
+++ b/src/check_builtin.cpp
@@ -1780,7 +1780,12 @@ gb_internal bool check_builtin_procedure(CheckerContext *c, Operand *operand, As
 			mode  = Addressing_Constant;
 			value = exact_value_i64(bt->SimdVector.count);
 			type  = t_untyped_integer;
-		}
+		} else if (is_type_union(op_type)) {
+            Type *u = base_type(op_type);
+			mode  = Addressing_Constant;
+			value = exact_value_i64(u->Union.variants.count);
+			type  = t_untyped_integer;
+        }
 		if (operand->mode == Addressing_Type && mode != Addressing_Constant) {
 			mode = Addressing_Invalid;
 		}
@@ -5117,6 +5122,138 @@ gb_internal bool check_builtin_procedure(CheckerContext *c, Operand *operand, As
 		}
 		break;
 
+	case BuiltinProc_type_union_tag:
+		{
+			if (operand->mode != Addressing_Type) {
+				error(operand->expr, "Expected a type for '%.*s'", LIT(builtin_name));
+				operand->mode = Addressing_Invalid;
+				operand->type = t_invalid;
+				return false;
+			}
+
+			Type *u = operand->type;
+
+			if (!is_type_union(u)) {
+				error(operand->expr, "Expected a union type for '%.*s'", LIT(builtin_name));
+				operand->mode = Addressing_Invalid;
+				operand->type = t_invalid;
+				return false;
+			}
+
+			u = base_type(u);
+			GB_ASSERT(u->kind == Type_Union);
+			
+			operand->mode = Addressing_Type;
+			operand->type = union_tag_type(u);
+		}
+		break;
+		
+	case BuiltinProc_type_union_tag_offset:
+		{
+			if (operand->mode != Addressing_Type) {
+				error(operand->expr, "Expected a type for '%.*s'", LIT(builtin_name));
+				operand->mode = Addressing_Invalid;
+				operand->type = t_invalid;
+				return false;
+			}
+
+			Type *u = operand->type;
+
+			if (!is_type_union(u)) {
+				error(operand->expr, "Expected a union type for '%.*s'", LIT(builtin_name));
+				operand->mode = Addressing_Invalid;
+				operand->type = t_invalid;
+				return false;
+			}
+
+			u = base_type(u);
+			GB_ASSERT(u->kind == Type_Union);
+			
+			// NOTE(jakubtomsu): forces calculation of variant_block_size
+			type_size_of(u);
+			i64 tag_offset = u->Union.variant_block_size;
+			GB_ASSERT(tag_offset > 0);
+			
+			operand->mode = Addressing_Constant;
+			operand->type = t_untyped_integer;
+			operand->value = exact_value_i64(tag_offset);
+		}
+		break;
+
+	case BuiltinProc_type_variant_type:
+		{
+			if (operand->mode != Addressing_Type) {
+				error(operand->expr, "Expected a type for '%.*s'", LIT(builtin_name));
+				operand->mode = Addressing_Invalid;
+				operand->type = t_invalid;
+				return false;
+			}
+
+			Type *u = operand->type;
+
+			if (!is_type_union(u)) {
+				error(operand->expr, "Expected a union type for '%.*s'", LIT(builtin_name));
+				operand->mode = Addressing_Invalid;
+				operand->type = t_invalid;
+				return false;
+			}
+
+			u = base_type(u);
+			GB_ASSERT(u->kind == Type_Union);
+			Operand x = {};
+			check_expr_or_type(c, &x, ce->args[1]);
+			if (!is_type_integer(x.type) || x.mode != Addressing_Constant) {
+				error(call, "Expected a constant integer for '%.*s", LIT(builtin_name));
+				operand->mode = Addressing_Type;
+				operand->type = t_invalid;
+				return false;
+			}
+			
+			i64 index = big_int_to_i64(&x.value.value_integer);
+			if (u->Union.kind != UnionType_no_nil) {
+				index -= 1;
+			}
+			
+			if (index < 0 || index >= u->Union.variants.count) {
+				error(call, "Variant tag out of bounds index for '%.*s", LIT(builtin_name));
+				operand->mode = Addressing_Type;
+				operand->type = t_invalid;
+				return false;
+			}
+
+			operand->mode = Addressing_Type;
+			operand->type = u->Union.variants[index];
+		}
+		break;
+	
+	case BuiltinProc_type_variant_tag:
+		{
+			if (operand->mode != Addressing_Type) {
+				error(operand->expr, "Expected a type for '%.*s'", LIT(builtin_name));
+				operand->mode = Addressing_Invalid;
+				operand->type = t_invalid;
+				return false;
+			}
+
+			Type *u = operand->type;
+
+			if (!is_type_union(u)) {
+				error(operand->expr, "Expected a union type for '%.*s'", LIT(builtin_name));
+				operand->mode = Addressing_Invalid;
+				operand->type = t_invalid;
+				return false;
+			}
+
+			Type *v = check_type(c, ce->args[1]);
+			u = base_type(u);
+			GB_ASSERT(u->kind == Type_Union);
+			
+			operand->mode = Addressing_Constant;
+			operand->type = t_untyped_integer;
+			operand->value = exact_value_i64(union_variant_index(u, v));
+		}
+		break;
+
 	case BuiltinProc_type_struct_field_count:
 		operand->value = exact_value_i64(0);
 		if (operand->mode != Addressing_Type) {