Remove Maybe type; Enum names

code/demo.odin

@@ -10,17 +10,28 @@
 #import ht "http_test.odin";
 
 main :: proc() {
+	{
+		Fruit :: enum {
+			APPLE,
+			BANANA,
+			COCONUT,
+		}
+
+		fmt.println(Fruit.names);
+	}
+
+when false {
 	{
 		m: map[f32]int;
-		reserve(^m, 16);
+		reserve(m, 16);
 		defer free(m);
 
 		m[1.0] = 1278;
 		m[2.0] = 7643;
 		m[3.0] = 564;
-		c := m[3.0];
 		_, ok := m[3.0];
-		// assert(ok && c == 564);
+		c := m[3.0];
+		assert(ok && c == 564);
 
 		fmt.print("map[");
 		i := 0;
@@ -28,7 +39,7 @@ main :: proc() {
 			if i > 0 {
 				fmt.print(", ");
 			}
-			fmt.printf("%f=%v", key, val);
+			fmt.printf("%v=%v", key, val);
 			i += 1;
 		}
 		fmt.println("]");
@@ -48,48 +59,36 @@ main :: proc() {
 		fmt.println(m);
 	}
 
-
-
-	// fm: map[128, int]f32;
-
-/*
 	{
-		sig: u32;
+		fmt.println("Hellope!");
-		x := __cpuid(0, ^sig);
-		fmt.println(sig, x);
-	}
 
+		x: [dynamic]f64;
+		reserve(x, 16);
+		defer free(x);
+		append(x, 2_000_000.500_000, 3, 5, 7);
 
+		for p, i in x {
+			if i > 0 { fmt.print(", "); }
+			fmt.print(p);
+		}
+		fmt.println();
 
-	i: int;
+		{
+			Vec3 :: [vector 3]f32;
 
-	fmt.println("Hellope!");
+			x := Vec3{1, 2, 3};
+			y := Vec3{4, 5, 6};
+			fmt.println(x < y);
+			fmt.println(x + y);
+			fmt.println(x - y);
+			fmt.println(x * y);
+			fmt.println(x / y);
 
-	x: [dynamic]f64;
+			for i in x {
-	defer free(x);
+				fmt.println(i);
-	append(^x, 2_000_000.500_000, 3, 5, 7);
+			}
-
-	for p, i in x {
-		if i > 0 { fmt.print(", "); }
-		fmt.print(p);
-	}
-	fmt.println();
-
-	{
-		Vec3 :: [vector 3]f32;
-
-		x := Vec3{1, 2, 3};
-		y := Vec3{4, 5, 6};
-		fmt.println(x < y);
-		fmt.println(x + y);
-		fmt.println(x - y);
-		fmt.println(x * y);
-		fmt.println(x / y);
-
-		for i in x {
-			fmt.println(i);
 		}
 	}
-*/
+}
 }
 

core/_preload.odin

@@ -52,15 +52,12 @@ Type_Info :: union {
 	Float: struct #ordered {
 		size: int, // in bytes
 	},
-	Any:     struct #ordered {},
 	String:  struct #ordered {},
 	Boolean: struct #ordered {},
+	Any:     struct #ordered {},
 	Pointer: struct #ordered {
 		elem: ^Type_Info, // nil -> rawptr
 	},
-	Maybe: struct #ordered {
-		elem: ^Type_Info,
-	},
 	Procedure: struct #ordered {
 		params:     ^Type_Info, // Type_Info.Tuple
 		results:    ^Type_Info, // Type_Info.Tuple
@@ -146,6 +143,8 @@ __cpuid :: proc(level: u32, sig: ^u32) -> i32 #foreign __llvm_core "__get_cpuid"
 
 
 
+
+
 // IMPORTANT NOTE(bill): Must be in this order (as the compiler relies upon it)
 Allocator_Mode :: enum u8 {
 	ALLOC,
@@ -199,23 +198,17 @@ free_ptr_with_allocator :: proc(a: Allocator, ptr: rawptr) #inline {
 	if ptr == nil {
 		return;
 	}
+	if a.procedure == nil {
+		return;
+	}
 	a.procedure(a.data, Allocator_Mode.FREE, 0, 0, ptr, 0, 0);
 }
 
-__free_raw_dynamic_array :: proc(a: ^Raw_Dynamic_Array) {
-	if a.allocator.procedure == nil {
-		return;
-	}
-	if a.data == nil {
-		return;
-	}
-	free_ptr_with_allocator(a.allocator, a.data);
-}
-
 free_ptr :: proc(ptr: rawptr) #inline {
 	__check_context();
 	free_ptr_with_allocator(context.allocator, ptr);
 }
+
 free_all :: proc() #inline {
 	__check_context();
 	a := context.allocator;
@@ -306,11 +299,11 @@ __string_eq :: proc(a, b: string) -> bool {
 	if a.data == b.data {
 		return true;
 	}
-	return mem.compare(cast(rawptr)a.data, cast(rawptr)b.data, a.count) == 0;
+	return __string_cmp(a, b) == 0;
 }
 
 __string_cmp :: proc(a, b: string) -> int {
-	return mem.compare(cast(rawptr)a.data, cast(rawptr)b.data, min(a.count, b.count));
+	return mem.compare(cast([]byte)a, cast([]byte)b);
 }
 
 __string_ne :: proc(a, b: string) -> bool #inline { return !__string_eq(a, b); }
@@ -504,7 +497,7 @@ __dynamic_map_rehash :: proc(using header: __Map_Header, new_count: int) {
 	nm: Raw_Dynamic_Map;
 	new_header.m = ^nm;
 
-	reserve(^nm.hashes, new_count);
+	reserve(nm.hashes, new_count);
 	nm.hashes.count = nm.hashes.capacity;
 	__dynamic_array_reserve(^nm.entries, entry_size, entry_align, m.entries.count);
 	for _, i in nm.hashes {
@@ -660,3 +653,13 @@ __dynamic_map_erase :: proc(using h: __Map_Header, fr: __Map_Find_Result) {
 		m.hashes[last.hash_index] = fr.entry_index;
 	}
 }
+
+
+__print_ti_ptr :: proc(ti: ^Type_Info) {
+	fmt.println(ti);
+	match type e in ti {
+	case Type_Info.Enum:
+		fmt.println(e.names);
+	}
+}
+

core/fmt.odin

@@ -134,9 +134,6 @@ buffer_write_type :: proc(buf: ^Buffer, ti: ^Type_Info) {
 			buffer_write_string(buf, "^");
 			buffer_write_type(buf, info.elem);
 		}
-	case Maybe:
-		buffer_write_string(buf, "?");
-		buffer_write_type(buf, info.elem);
 	case Procedure:
 		buffer_write_string(buf, "proc");
 		if info.params == nil {
@@ -420,8 +417,9 @@ fmt_write_padding :: proc(fi: ^Fmt_Info, width: int) {
 }
 
 fmt_integer :: proc(fi: ^Fmt_Info, u: u64, base: int, signed: bool, digits: string) {
-	negative := signed && cast(i64)u < 0;
+	s := cast(i64)u;
-	u = abs(u);
+	negative := signed && s < 0;
+	u = cast(u64)abs(s);
 	buf: [256]byte;
 	if fi.width_set || fi.prec_set {
 		width := fi.width + fi.prec + 3;
@@ -628,6 +626,7 @@ fmt_string :: proc(fi: ^Fmt_Info, s: string, verb: rune) {
 fmt_pointer :: proc(fi: ^Fmt_Info, p: rawptr, verb: rune) {
 	match verb {
 	case 'p', 'v':
+		// Okay
 	default:
 		fmt_bad_verb(fi, verb);
 		return;
@@ -747,16 +746,6 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
 			fmt_pointer(fi, (cast(^rawptr)v.data)^, verb);
 		}
 
-	case Maybe:
-		// TODO(bill): Correct verbs for Maybe types?
-		size := mem.size_of_type_info(info.elem);
-		data := slice_ptr(cast(^byte)v.data, size+1);
-		if data[size] != 0 {
-			fmt_arg(fi, any{info.elem, v.data}, verb);
-		} else {
-			buffer_write_string(fi.buf, "nil");
-		}
-
 	case Array:
 		if verb != 'v' {
 			fmt_bad_verb(fi, verb);
@@ -799,9 +788,10 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
 		buffer_write_string(fi.buf, "map[");
 		defer buffer_write_byte(fi.buf, ']');
 		entries := ^(cast(^Raw_Dynamic_Map)v.data).entries;
-		gs, _ := union_cast(^Struct)info.generated_struct;
+		gs, gs_ok := union_cast(^Struct)type_info_base(info.generated_struct);         assert(gs_ok);
-		ed, _ := union_cast(^Dynamic_Array)gs.fields[1].type_info;
+		ed, ed_ok := union_cast(^Dynamic_Array)type_info_base(gs.fields[1].type_info); assert(ed_ok);
-		entry_type, _ := union_cast(^Struct)ed.elem;
+
+		entry_type, et_ok := union_cast(^Struct)ed.elem; assert(et_ok);
 		entry_size := ed.elem_size;
 		for i in 0..<entries.count {
 			if i > 0 {

core/math.odin

@@ -46,10 +46,6 @@ bit_reverse :: proc(b: u16) -> u16 #foreign __llvm_core "llvm.bitreverse.i16";
 bit_reverse :: proc(b: u32) -> u32 #foreign __llvm_core "llvm.bitreverse.i32";
 bit_reverse :: proc(b: u64) -> u64 #foreign __llvm_core "llvm.bitreverse.i64";
 
-byte_swap :: proc(b: u16) -> u16 #foreign __llvm_core "llvm.bswap.i16";
-byte_swap :: proc(b: u32) -> u32 #foreign __llvm_core "llvm.bswap.i32";
-byte_swap :: proc(b: u64) -> u64 #foreign __llvm_core "llvm.bswap.i64";
-
 fmuladd :: proc(a, b, c: f32) -> f32 #foreign __llvm_core "llvm.fmuladd.f32";
 fmuladd :: proc(a, b, c: f64) -> f64 #foreign __llvm_core "llvm.fmuladd.f64";
 

core/mem.odin

@@ -1,6 +1,11 @@
 #import "fmt.odin";
 #import "os.odin";
 
+swap :: proc(b: u16) -> u16 #foreign __llvm_core "llvm.bswap.i16";
+swap :: proc(b: u32) -> u32 #foreign __llvm_core "llvm.bswap.i32";
+swap :: proc(b: u64) -> u64 #foreign __llvm_core "llvm.bswap.i64";
+
+
 set :: proc(data: rawptr, value: i32, len: int) -> rawptr #link_name "__mem_set" {
 	llvm_memset_64bit :: proc(dst: rawptr, val: byte, len: int, align: i32, is_volatile: bool) #foreign __llvm_core "llvm.memset.p0i8.i64";
 	llvm_memset_64bit(data, cast(byte)value, len, 1, false);
@@ -12,22 +17,21 @@ zero :: proc(data: rawptr, len: int) -> rawptr #link_name "__mem_zero" {
 }
 
 copy :: proc(dst, src: rawptr, len: int) -> rawptr #link_name "__mem_copy" {
-	// NOTE(bill): This _must_ implemented like C's memmove
+	// NOTE(bill): This _must_ be implemented like C's memmove
 	llvm_memmove_64bit :: proc(dst, src: rawptr, len: int, align: i32, is_volatile: bool) #foreign __llvm_core "llvm.memmove.p0i8.p0i8.i64";
 	llvm_memmove_64bit(dst, src, len, 1, false);
 	return dst;
 }
 
 copy_non_overlapping :: proc(dst, src: rawptr, len: int) -> rawptr #link_name "__mem_copy_non_overlapping" {
-	// NOTE(bill): This _must_ implemented like C's memcpy
+	// NOTE(bill): This _must_ be implemented like C's memcpy
 	llvm_memcpy_64bit :: proc(dst, src: rawptr, len: int, align: i32, is_volatile: bool) #foreign __llvm_core "llvm.memcpy.p0i8.p0i8.i64";
 	llvm_memcpy_64bit(dst, src, len, 1, false);
 	return dst;
 }
 
-compare :: proc(dst, src: rawptr, n: int) -> int #link_name "__mem_compare" {
+compare :: proc(a, b: []byte) -> int #link_name "__mem_compare" {
-	a := slice_ptr(cast(^byte)dst, n);
+	n := min(a.count, b.count);
-	b := slice_ptr(cast(^byte)src, n);
 	for i in 0..<n {
 		match {
 		case a[i] < b[i]:
@@ -43,8 +47,8 @@ compare :: proc(dst, src: rawptr, n: int) -> int #link_name "__mem_compare" {
 
 kilobytes :: proc(x: int) -> int #inline { return          (x) * 1024; }
 megabytes :: proc(x: int) -> int #inline { return kilobytes(x) * 1024; }
-gigabytes :: proc(x: int) -> int #inline { return gigabytes(x) * 1024; }
+gigabytes :: proc(x: int) -> int #inline { return megabytes(x) * 1024; }
-terabytes :: proc(x: int) -> int #inline { return terabytes(x) * 1024; }
+terabytes :: proc(x: int) -> int #inline { return gigabytes(x) * 1024; }
 
 is_power_of_two :: proc(x: int) -> bool {
 	if x <= 0 {
@@ -213,7 +217,6 @@ align_of_type_info :: proc(type_info: ^Type_Info) -> int {
 	WORD_SIZE :: size_of(int);
 	MAX_ALIGN :: size_of([vector 64]f64); // TODO(bill): Should these constants be builtin constants?
 	using Type_Info;
-
 	match type info in type_info {
 	case Named:
 		return align_of_type_info(info.base);
@@ -225,14 +228,16 @@ align_of_type_info :: proc(type_info: ^Type_Info) -> int {
 		return WORD_SIZE;
 	case Boolean:
 		return 1;
+	case Any:
+		return WORD_SIZE;
 	case Pointer:
 		return WORD_SIZE;
-	case Maybe:
-		return max(align_of_type_info(info.elem), 1);
 	case Procedure:
 		return WORD_SIZE;
 	case Array:
 		return align_of_type_info(info.elem);
+	case Dynamic_Array:
+		return WORD_SIZE;
 	case Slice:
 		return WORD_SIZE;
 	case Vector:
@@ -240,12 +245,18 @@ align_of_type_info :: proc(type_info: ^Type_Info) -> int {
 		count := cast(int)max(prev_pow2(cast(i64)info.count), 1);
 		total := size * count;
 		return clamp(total, 1, MAX_ALIGN);
+	case Tuple:
+		return info.align;
 	case Struct:
 		return info.align;
 	case Union:
 		return info.align;
 	case Raw_Union:
 		return info.align;
+	case Enum:
+		return align_of_type_info(info.base);
+	case Map:
+		return align_of_type_info(info.generated_struct);
 	}
 
 	return 0;
@@ -266,16 +277,14 @@ size_of_type_info :: proc(type_info: ^Type_Info) -> int {
 		return info.size;
 	case Float:
 		return info.size;
-	case Any:
-		return 2*WORD_SIZE;
 	case String:
 		return 2*WORD_SIZE;
 	case Boolean:
 		return 1;
+	case Any:
+		return 2*WORD_SIZE;
 	case Pointer:
 		return WORD_SIZE;
-	case Maybe:
-		return size_of_type_info(info.elem) + 1;
 	case Procedure:
 		return WORD_SIZE;
 	case Array:
@@ -287,39 +296,29 @@ size_of_type_info :: proc(type_info: ^Type_Info) -> int {
 		align     := align_of_type_info(info.elem);
 		alignment := align_formula(size, align);
 		return alignment*(count-1) + size;
+	case Dynamic_Array:
+		return size_of(rawptr) + 2*size_of(int) + size_of(Allocator);
 	case Slice:
-		return 3*WORD_SIZE;
+		return 2*WORD_SIZE;
 	case Vector:
-		is_bool :: proc(type_info: ^Type_Info) -> bool {
-			match type info in type_info {
-			case Named:
-				return is_bool(info.base);
-			case Boolean:
-				return true;
-			}
-			return false;
-		}
-
 		count := info.count;
 		if count == 0 {
 			return 0;
 		}
-		bit_size := 8*size_of_type_info(info.elem);
+		size      := size_of_type_info(info.elem);
-		if is_bool(info.elem) {
+		align     := align_of_type_info(info.elem);
-			// NOTE(bill): LLVM can store booleans as 1 bit because a boolean _is_ an `i1`
+		alignment := align_formula(size, align);
-			// Silly LLVM spec
+		return alignment*(count-1) + size;
-			bit_size = 1;
-		}
-		total_size_in_bits := bit_size * count;
-		total_size := (total_size_in_bits+7)/8;
-		return total_size;
-
 	case Struct:
 		return info.size;
 	case Union:
 		return info.size;
 	case Raw_Union:
 		return info.size;
+	case Enum:
+		return size_of_type_info(info.base);
+	case Map:
+		return size_of_type_info(info.generated_struct);
 	}
 
 	return 0;

core/sys/windows.odin

@@ -1,3 +1,4 @@
+_ := compile_assert(ODIN_OS == "windows");
 #foreign_system_library "kernel32.lib";
 #foreign_system_library "user32.lib";
 #foreign_system_library "gdi32.lib";

core/types.odin

@@ -56,14 +56,6 @@ is_pointer :: proc(info: ^Type_Info) -> bool {
 	}
 	return false;
 }
-is_maybe :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
-
-	match type i in type_info_base(info) {
-	case Type_Info.Maybe: return true;
-	}
-	return false;
-}
 is_procedure :: proc(info: ^Type_Info) -> bool {
 	if info == nil { return false; }
 
@@ -88,6 +80,14 @@ is_dynamic_array :: proc(info: ^Type_Info) -> bool {
 	}
 	return false;
 }
+is_dynamic_map :: proc(info: ^Type_Info) -> bool {
+	if info == nil { return false; }
+
+	match type i in type_info_base(info) {
+	case Type_Info.Map: return i.count == 0;
+	}
+	return false;
+}
 is_slice :: proc(info: ^Type_Info) -> bool {
 	if info == nil { return false; }
 

src/checker.c

@@ -630,11 +630,12 @@ void init_universal_scope(BuildContext *bc) {
 	}
 
 
-	t_u8_ptr  = make_type_pointer(a, t_u8);
+	t_u8_ptr       = make_type_pointer(a, t_u8);
-	t_int_ptr = make_type_pointer(a, t_int);
+	t_int_ptr      = make_type_pointer(a, t_int);
-	t_i64_ptr = make_type_pointer(a, t_i64);
+	t_i64_ptr      = make_type_pointer(a, t_i64);
-	t_f64_ptr = make_type_pointer(a, t_f64);
+	t_f64_ptr      = make_type_pointer(a, t_f64);
-	t_byte_slice = make_type_slice(a, t_byte);
+	t_byte_slice   = make_type_slice(a, t_byte);
+	t_string_slice = make_type_slice(a, t_string);
 }
 
 
@@ -911,11 +912,6 @@ void add_type_info_type(Checker *c, Type *t) {
 		}
 	} break;
 
-	case Type_Maybe:
-		add_type_info_type(c, bt->Maybe.elem);
-		add_type_info_type(c, t_bool);
-		break;
-
 	case Type_Pointer:
 		add_type_info_type(c, bt->Pointer.elem);
 		break;
@@ -1099,48 +1095,46 @@ void init_preload(Checker *c) {
 
 
 
-		if (record->field_count != 20) {
+		if (record->field_count != 19) {
 			compiler_error("Invalid `Type_Info` layout");
 		}
 		t_type_info_named         = record->fields[ 1]->type;
 		t_type_info_integer       = record->fields[ 2]->type;
 		t_type_info_float         = record->fields[ 3]->type;
-		t_type_info_any           = record->fields[ 4]->type;
+		t_type_info_string        = record->fields[ 4]->type;
-		t_type_info_string        = record->fields[ 5]->type;
+		t_type_info_boolean       = record->fields[ 5]->type;
-		t_type_info_boolean       = record->fields[ 6]->type;
+		t_type_info_any           = record->fields[ 6]->type;
 		t_type_info_pointer       = record->fields[ 7]->type;
-		t_type_info_maybe         = record->fields[ 8]->type;
+		t_type_info_procedure     = record->fields[ 8]->type;
-		t_type_info_procedure     = record->fields[ 9]->type;
+		t_type_info_array         = record->fields[ 9]->type;
-		t_type_info_array         = record->fields[10]->type;
+		t_type_info_dynamic_array = record->fields[10]->type;
-		t_type_info_dynamic_array = record->fields[11]->type;
+		t_type_info_slice         = record->fields[11]->type;
-		t_type_info_slice         = record->fields[12]->type;
+		t_type_info_vector        = record->fields[12]->type;
-		t_type_info_vector        = record->fields[13]->type;
+		t_type_info_tuple         = record->fields[13]->type;
-		t_type_info_tuple         = record->fields[14]->type;
+		t_type_info_struct        = record->fields[14]->type;
-		t_type_info_struct        = record->fields[15]->type;
+		t_type_info_union         = record->fields[15]->type;
-		t_type_info_union         = record->fields[16]->type;
+		t_type_info_raw_union     = record->fields[16]->type;
-		t_type_info_raw_union     = record->fields[17]->type;
+		t_type_info_enum          = record->fields[17]->type;
-		t_type_info_enum          = record->fields[18]->type;
+		t_type_info_map           = record->fields[18]->type;
-		t_type_info_map           = record->fields[19]->type;
 
-		t_type_info_named_ptr         = make_type_pointer(heap_allocator(), t_type_info_named);
+		t_type_info_named_ptr         = make_type_pointer(c->allocator, t_type_info_named);
-		t_type_info_integer_ptr       = make_type_pointer(heap_allocator(), t_type_info_integer);
+		t_type_info_integer_ptr       = make_type_pointer(c->allocator, t_type_info_integer);
-		t_type_info_float_ptr         = make_type_pointer(heap_allocator(), t_type_info_float);
+		t_type_info_float_ptr         = make_type_pointer(c->allocator, t_type_info_float);
-		t_type_info_any_ptr           = make_type_pointer(heap_allocator(), t_type_info_any);
+		t_type_info_string_ptr        = make_type_pointer(c->allocator, t_type_info_string);
-		t_type_info_string_ptr        = make_type_pointer(heap_allocator(), t_type_info_string);
+		t_type_info_boolean_ptr       = make_type_pointer(c->allocator, t_type_info_boolean);
-		t_type_info_boolean_ptr       = make_type_pointer(heap_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(heap_allocator(), t_type_info_pointer);
+		t_type_info_pointer_ptr       = make_type_pointer(c->allocator, t_type_info_pointer);
-		t_type_info_maybe_ptr         = make_type_pointer(heap_allocator(), t_type_info_maybe);
+		t_type_info_procedure_ptr     = make_type_pointer(c->allocator, t_type_info_procedure);
-		t_type_info_procedure_ptr     = make_type_pointer(heap_allocator(), t_type_info_procedure);
+		t_type_info_array_ptr         = make_type_pointer(c->allocator, t_type_info_array);
-		t_type_info_array_ptr         = make_type_pointer(heap_allocator(), t_type_info_array);
+		t_type_info_dynamic_array_ptr = make_type_pointer(c->allocator, t_type_info_dynamic_array);
-		t_type_info_dynamic_array_ptr = make_type_pointer(heap_allocator(), t_type_info_dynamic_array);
+		t_type_info_slice_ptr         = make_type_pointer(c->allocator, t_type_info_slice);
-		t_type_info_slice_ptr         = make_type_pointer(heap_allocator(), t_type_info_slice);
+		t_type_info_vector_ptr        = make_type_pointer(c->allocator, t_type_info_vector);
-		t_type_info_vector_ptr        = make_type_pointer(heap_allocator(), t_type_info_vector);
+		t_type_info_tuple_ptr         = make_type_pointer(c->allocator, t_type_info_tuple);
-		t_type_info_tuple_ptr         = make_type_pointer(heap_allocator(), t_type_info_tuple);
+		t_type_info_struct_ptr        = make_type_pointer(c->allocator, t_type_info_struct);
-		t_type_info_struct_ptr        = make_type_pointer(heap_allocator(), t_type_info_struct);
+		t_type_info_union_ptr         = make_type_pointer(c->allocator, t_type_info_union);
-		t_type_info_union_ptr         = make_type_pointer(heap_allocator(), t_type_info_union);
+		t_type_info_raw_union_ptr     = make_type_pointer(c->allocator, t_type_info_raw_union);
-		t_type_info_raw_union_ptr     = make_type_pointer(heap_allocator(), t_type_info_raw_union);
+		t_type_info_enum_ptr          = make_type_pointer(c->allocator, t_type_info_enum);
-		t_type_info_enum_ptr          = make_type_pointer(heap_allocator(), t_type_info_enum);
+		t_type_info_map_ptr           = make_type_pointer(c->allocator, t_type_info_map);
-		t_type_info_map_ptr           = make_type_pointer(heap_allocator(), t_type_info_map);
 	}
 
 	if (t_allocator == NULL) {
@@ -1714,6 +1708,19 @@ void check_import_entities(Checker *c, MapScope *file_scopes) {
 			file_str = import_file;
 		}
 
+		if (fl->cond != NULL) {
+			Operand operand = {Addressing_Invalid};
+			check_expr(c, &operand, fl->cond);
+			if (operand.mode != Addressing_Constant || !is_type_boolean(operand.type)) {
+				error_node(fl->cond, "Non-constant boolean `when` condition");
+				continue;
+			}
+			if (operand.value.kind == ExactValue_Bool &&
+			    !operand.value.value_bool) {
+				continue;
+			}
+		}
+
 		String library_name = path_to_entity_name(fl->library_name.string, file_str);
 		if (str_eq(library_name, str_lit("_"))) {
 			error(fl->token, "File name, %.*s, cannot be as a library name as it is not a valid identifier", LIT(fl->library_name.string));

src/entity.c

@@ -37,6 +37,7 @@ typedef enum EntityFlag {
 	EntityFlag_VectorElem = 1<<5,
 	EntityFlag_Ellipsis   = 1<<6,
 	EntityFlag_NoAlias    = 1<<7,
+	EntityFlag_EnumField  = 1<<8,
 } EntityFlag;
 
 typedef enum OverloadKind {

src/ir.c

@@ -1788,11 +1788,6 @@ irValue *ir_emit_struct_ep(irProcedure *proc, irValue *s, i32 index) {
 		case 0: result_type = make_type_pointer(a, t_type_info_ptr); break;
 		case 1: result_type = make_type_pointer(a, t_rawptr);        break;
 		}
-	} else if (is_type_maybe(t)) {
-		switch (index) {
-		case 0: result_type = make_type_pointer(a, t->Maybe.elem); break;
-		case 1: result_type = make_type_pointer(a, t_bool);        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;
@@ -1848,11 +1843,6 @@ irValue *ir_emit_struct_ev(irProcedure *proc, irValue *s, i32 index) {
 		case 0: result_type = t_type_info_ptr; break;
 		case 1: result_type = t_rawptr;        break;
 		}
-	} else if (is_type_maybe(t)) {
-		switch (index) {
-		case 0: result_type = t->Maybe.elem; break;
-		case 1: result_type = t_bool;        break;
-		}
 	} else if (is_type_dynamic_array(t)) {
 		switch (index) {
 		case 0: result_type = make_type_pointer(a, t->DynamicArray.elem); break;
@@ -2165,15 +2155,6 @@ irValue *ir_emit_conv(irProcedure *proc, irValue *value, Type *t) {
 		return value;
 	}
 
-	if (is_type_maybe(dst)) {
-		irValue *maybe = ir_add_local_generated(proc, dst);
-		irValue *val = ir_emit_struct_ep(proc, maybe, 0);
-		irValue *set = ir_emit_struct_ep(proc, maybe, 1);
-		ir_emit_store(proc, val, value);
-		ir_emit_store(proc, set, v_true);
-		return ir_emit_load(proc, maybe);
-	}
-
 	// integer -> integer
 	if (is_type_integer(src) && is_type_integer(dst)) {
 		GB_ASSERT(src->kind == Type_Basic &&
@@ -2396,7 +2377,6 @@ bool ir_is_type_aggregate(Type *t) {
 
 	case Type_Array:
 	case Type_Slice:
-	case Type_Maybe:
 	case Type_Record:
 	case Type_Tuple:
 		return true;
@@ -3130,22 +3110,33 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv
 						args[1] = ptr;
 						return ir_emit_global_call(proc, "free_ptr_with_allocator", args, 2);
 					} else if (is_type_dynamic_map(type)) {
-						// irValue *val = ir_build_expr(proc, node);
+						irValue *map = ir_build_expr(proc, node);
-						// irValue *map_ptr = ir_address_from_load_or_generate_local(proc, val);
+						irValue *map_ptr = ir_address_from_load_or_generate_local(proc, map);
 
-						// {
+						{
-						// 	irValue *array = ir_emit_conv(proc, ir_emit_struct_ep(proc, map_ptr, 0), t_raw_dynamic_array_ptr);
+							irValue *array = ir_emit_struct_ep(proc, map_ptr, 0);
-						// 	irValue **args = gb_alloc_array(a, irValue *, 1);
-						// 	args[0] = array;
-						// 	ir_emit_global_call(proc, "__free_raw_dynamic_array", args, 1);
-						// }
-						// {
-						// 	irValue *array = ir_emit_conv(proc, ir_emit_struct_ep(proc, map_ptr, 1), t_raw_dynamic_array_ptr);
-						// 	irValue **args = gb_alloc_array(a, irValue *, 1);
-						// 	args[0] = array;
-						// 	ir_emit_global_call(proc, "__free_raw_dynamic_array", args, 1);
-						// }
 
+							irValue *da_allocator = ir_emit_load(proc, ir_emit_struct_ep(proc, array, 3));
+							irValue *da_ptr = ir_emit_load(proc, ir_emit_struct_ep(proc, array, 0));
+							da_ptr = ir_emit_conv(proc, da_ptr, t_rawptr);
+
+							irValue **args = gb_alloc_array(a, irValue *, 1);
+							args[0] = da_allocator;
+							args[1] = da_ptr;
+							ir_emit_global_call(proc, "free_ptr_with_allocator", args, 2);
+						}
+						{
+							irValue *array = ir_emit_struct_ep(proc, map_ptr, 1);
+
+							irValue *da_allocator = ir_emit_load(proc, ir_emit_struct_ep(proc, array, 3));
+							irValue *da_ptr = ir_emit_load(proc, ir_emit_struct_ep(proc, array, 0));
+							da_ptr = ir_emit_conv(proc, da_ptr, t_rawptr);
+
+							irValue **args = gb_alloc_array(a, irValue *, 1);
+							args[0] = da_allocator;
+							args[1] = da_ptr;
+							ir_emit_global_call(proc, "free_ptr_with_allocator", args, 2);
+						}
 						return NULL;
 					}
 
@@ -3176,7 +3167,7 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv
 					ir_emit_comment(proc, str_lit("reserve"));
 					gbAllocator a = proc->module->allocator;
 
-					irValue *ptr = ir_build_expr(proc, ce->args.e[0]);
+					irValue *ptr = ir_build_addr(proc, ce->args.e[0]).addr;
 					Type *type = ir_type(ptr);
 					GB_ASSERT(is_type_pointer(type));
 					type = base_type(type_deref(type));
@@ -3208,8 +3199,8 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv
 				} break;
 
 				case BuiltinProc_clear: {
-					ir_emit_comment(proc, str_lit("reserve"));
+					ir_emit_comment(proc, str_lit("clear"));
-					irValue *ptr = ir_build_expr(proc, ce->args.e[0]);
+					irValue *ptr = ir_build_addr(proc, ce->args.e[0]).addr;
 					Type *t = base_type(type_deref(ir_type(ptr)));
 					if (is_type_dynamic_array(t)) {
 						irValue *count_ptr = ir_emit_struct_ep(proc, ptr, 1);
@@ -3229,7 +3220,7 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv
 					ir_emit_comment(proc, str_lit("append"));
 					gbAllocator a = proc->module->allocator;
 
-					irValue *array_ptr = ir_build_expr(proc, ce->args.e[0]);
+					irValue *array_ptr = ir_build_addr(proc, ce->args.e[0]).addr;
 					Type *type = ir_type(array_ptr);
 					GB_ASSERT(is_type_pointer(type));
 					type = base_type(type_deref(type));
@@ -3348,7 +3339,7 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv
 					ir_emit_jump(proc, done);
 					ir_start_block(proc, done);
 
-					return NULL;
+					return cond;
 				} break;
 
 				case BuiltinProc_panic: {
@@ -3596,10 +3587,6 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv
 		return ir_emit_call(proc, value, args, arg_count);
 	case_end;
 
-	case_ast_node(de, DemaybeExpr, expr);
-		return ir_addr_load(proc, ir_build_addr(proc, expr));
-	case_end;
-
 	case_ast_node(se, SliceExpr, expr);
 		return ir_addr_load(proc, ir_build_addr(proc, expr));
 	case_end;
@@ -3722,7 +3709,34 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
 		AstNode *sel = unparen_expr(se->selector);
 		if (sel->kind == AstNode_Ident) {
 			String selector = sel->Ident.string;
-			Type *type = base_type(type_of_expr(proc->module->info, se->expr));
+			Type *type = type_of_expr(proc->module->info, se->expr);
+
+			if (is_type_enum(type)) {
+				Selection sel = lookup_field(proc->module->allocator, type, selector, true);
+				Entity *e = sel.entity;
+				GB_ASSERT(e->kind == Entity_Variable);
+				i32 index = e->Variable.field_index;
+				switch (index) {
+				case 0: {
+					irValue *ti_ptr = ir_type_info(proc, type);
+					{
+						irValue **args = gb_alloc_array(proc->module->allocator, irValue *, 1);
+						args[0] = ti_ptr;
+						ti_ptr = ir_emit_global_call(proc, "type_info_base", args, 1);
+					}
+
+
+					irValue *enum_info = ir_emit_conv(proc, ti_ptr, t_type_info_enum_ptr);
+					irValue *names_ptr = ir_emit_struct_ep(proc, enum_info, 1);
+					return ir_make_addr(names_ptr);
+				} break;
+				default:
+					GB_PANIC("Unhandled enum index %d %.*s", index, LIT(selector));
+					break;
+				}
+			}
+
+			type = base_type(type);
 
 			if (type == t_invalid) {
 				// NOTE(bill): Imports
@@ -4056,18 +4070,6 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
 		return ir_make_addr(addr);
 	case_end;
 
-	case_ast_node(de, DemaybeExpr, expr);
-		ir_emit_comment(proc, str_lit("DemaybeExpr"));
-		irValue *maybe = ir_build_expr(proc, de->expr);
-		Type *t = default_type(type_of_expr(proc->module->info, expr));
-		GB_ASSERT(is_type_tuple(t));
-
-		irValue *result = ir_add_local_generated(proc, t);
-		ir_emit_store(proc, result, maybe);
-
-		return ir_make_addr(result);
-	case_end;
-
 	case_ast_node(ce, CallExpr, expr);
 		// NOTE(bill): This is make sure you never need to have an `array_ev`
 		irValue *e = ir_build_expr(proc, expr);
@@ -5276,6 +5278,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) {
 
 		String tag_var_name = ms->var->Ident.string;
 
+
 		AstNodeArray default_stmts = {0};
 		irBlock *default_block = NULL;
 
@@ -5291,19 +5294,32 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) {
 				default_block = ir_new_block(proc, clause, "type-match.dflt.body");
 				continue;
 			}
+			GB_ASSERT(cc->list.count == 1);
 
 
 			irBlock *body = ir_new_block(proc, clause, "type-match.case.body");
 
-			Scope *scope = *map_scope_get(&proc->module->info->scopes, hash_pointer(clause));
+			Entity *tag_var_entity = NULL;
-			Entity *tag_var_entity = current_scope_lookup_entity(scope, tag_var_name);
+			Type *tag_var_type = NULL;
-			GB_ASSERT_MSG(tag_var_entity != NULL, "%.*s", LIT(tag_var_name));
+			if (str_eq(tag_var_name, str_lit("_"))) {
+				Type *t = type_of_expr(proc->module->info, cc->list.e[0]);
+				if (is_union_ptr) {
+					t = make_type_pointer(proc->module->allocator, t);
+				}
+				tag_var_type = t;
+			} else {
+				Scope *scope = *map_scope_get(&proc->module->info->scopes, hash_pointer(clause));
+				tag_var_entity = current_scope_lookup_entity(scope, tag_var_name);
+				GB_ASSERT_MSG(tag_var_entity != NULL, "%.*s", LIT(tag_var_name));
+				tag_var_type = tag_var_entity->type;
+			}
+			GB_ASSERT(tag_var_type != NULL);
 
 			irBlock *next_cond = NULL;
 			irValue *cond = NULL;
 
 			if (is_union_ptr) {
-				Type *bt = type_deref(tag_var_entity->type);
+				Type *bt = type_deref(tag_var_type);
 				irValue *index = NULL;
 				Type *ut = base_type(type_deref(ir_type(parent)));
 				GB_ASSERT(ut->Record.kind == TypeRecord_Union);
@@ -5316,16 +5332,25 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) {
 				}
 				GB_ASSERT(index != NULL);
 
-				irValue *tag_var = ir_add_local(proc, tag_var_entity);
+				irValue *tag_var = NULL;
-				irValue *data_ptr = ir_emit_conv(proc, union_data, tag_var_entity->type);
+				if (tag_var_entity != NULL) {
+					tag_var = ir_add_local(proc, tag_var_entity);
+				} else {
+					tag_var = ir_add_local_generated(proc, tag_var_type);
+				}
+
+
+				irValue *data_ptr = ir_emit_conv(proc, union_data, tag_var_type);
 				ir_emit_store(proc, tag_var, data_ptr);
 
 				cond = ir_emit_comp(proc, Token_CmpEq, tag_index, index);
 			} else if (is_any) {
-				Type *type = tag_var_entity->type;
+				Type *type = tag_var_type;
 				irValue *any_data = ir_emit_struct_ev(proc, parent, 1);
 				irValue *data = ir_emit_conv(proc, any_data, make_type_pointer(proc->module->allocator, type));
-				ir_module_add_value(proc->module, tag_var_entity, data);
+				if (tag_var_entity != NULL) {
+					ir_module_add_value(proc->module, tag_var_entity, data);
+				}
 
 				irValue *any_ti  = ir_emit_struct_ev(proc, parent, 0);
 				irValue *case_ti = ir_type_info(proc, type);
@@ -6228,11 +6253,6 @@ void ir_gen_tree(irGen *s) {
 					irValue *gep = ir_get_type_info_ptr(proc, type_info_data, t->Pointer.elem);
 					ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
 				} break;
-				case Type_Maybe: {
-					tag = ir_emit_conv(proc, ti_ptr, t_type_info_maybe_ptr);
-					irValue *gep = ir_get_type_info_ptr(proc, type_info_data, t->Maybe.elem);
-					ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
-				} break;
 				case Type_Array: {
 					tag = ir_emit_conv(proc, ti_ptr, t_type_info_array_ptr);
 					irValue *gep = ir_get_type_info_ptr(proc, type_info_data, t->Array.elem);

src/ir_print.c

@@ -172,13 +172,6 @@ void ir_print_type(irFileBuffer *f, irModule *m, Type *t) {
 		ir_print_type(f, m, t->Pointer.elem);
 		ir_fprintf(f, "*");
 		return;
-	case Type_Maybe:
-		ir_fprintf(f, "{");
-		ir_print_type(f, m, t->Maybe.elem);
-		ir_fprintf(f, ", ");
-		ir_print_type(f, m, t_bool);
-		ir_fprintf(f, "}");
-		return;
 	case Type_Array:
 		ir_fprintf(f, "[%lld x ", t->Array.count);
 		ir_print_type(f, m, t->Array.elem);
@@ -306,25 +299,11 @@ void ir_print_compound_element(irFileBuffer *f, irModule *m, ExactValue v, Type
 	ir_print_type(f, m, elem_type);
 	ir_fprintf(f, " ");
 
-	if (v.kind != ExactValue_Invalid && is_type_maybe(elem_type)) {
-		Type *t = base_type(elem_type)->Maybe.elem;
-		ir_fprintf(f, "{");
-		ir_print_type(f, m, t);
-		ir_fprintf(f, " ");
-	}
-
 	if (v.kind == ExactValue_Invalid || base_type(elem_type) == t_any) {
 		ir_fprintf(f, "zeroinitializer");
 	} else {
 		ir_print_exact_value(f, m, v, elem_type);
 	}
-
-	if (v.kind != ExactValue_Invalid && is_type_maybe(elem_type)) {
-		ir_fprintf(f, ", ");
-		ir_print_type(f, m, t_bool);
-		ir_fprintf(f, " ");
-		ir_fprintf(f, "true}");
-	}
 }
 
 void ir_print_exact_value(irFileBuffer *f, irModule *m, ExactValue value, Type *type) {

src/parser.c

@@ -147,7 +147,6 @@ AST_NODE_KIND(_ExprBegin,  "",  i32) \
 	AST_NODE_KIND(SelectorExpr, "selector expression",    struct { Token token; AstNode *expr, *selector; }) \
 	AST_NODE_KIND(IndexExpr,    "index expression",       struct { AstNode *expr, *index; Token open, close; }) \
 	AST_NODE_KIND(DerefExpr,    "dereference expression", struct { Token op; AstNode *expr; }) \
-	AST_NODE_KIND(DemaybeExpr,  "demaybe expression",     struct { Token op; AstNode *expr; }) \
 	AST_NODE_KIND(SliceExpr, "slice expression", struct { \
 		AstNode *expr; \
 		Token open, close, interval; \
@@ -333,10 +332,6 @@ AST_NODE_KIND(_TypeBegin, "", i32) \
 		Token token; \
 		AstNode *type; \
 	}) \
-	AST_NODE_KIND(MaybeType, "maybe type", struct { \
-		Token token; \
-		AstNode *type; \
-	}) \
 	AST_NODE_KIND(ArrayType, "array type", struct { \
 		Token token; \
 		AstNode *count; \
@@ -469,7 +464,6 @@ Token ast_node_token(AstNode *node) {
 	case AstNode_CastExpr:     return node->CastExpr.token;
 	case AstNode_FieldValue:   return node->FieldValue.eq;
 	case AstNode_DerefExpr:    return node->DerefExpr.op;
-	case AstNode_DemaybeExpr:  return node->DemaybeExpr.op;
 	case AstNode_BlockExpr:    return node->BlockExpr.open;
 	case AstNode_GiveExpr:     return node->GiveExpr.token;
 	case AstNode_IfExpr:       return node->IfExpr.token;
@@ -513,7 +507,6 @@ Token ast_node_token(AstNode *node) {
 	case AstNode_HelperType:       return node->HelperType.token;
 	case AstNode_ProcType:         return node->ProcType.token;
 	case AstNode_PointerType:      return node->PointerType.token;
-	case AstNode_MaybeType:        return node->MaybeType.token;
 	case AstNode_ArrayType:        return node->ArrayType.token;
 	case AstNode_DynamicArrayType: return node->DynamicArrayType.token;
 	case AstNode_VectorType:       return node->VectorType.token;
@@ -693,13 +686,6 @@ AstNode *ast_deref_expr(AstFile *f, AstNode *expr, Token op) {
 	return result;
 }
 
-AstNode *ast_demaybe_expr(AstFile *f, AstNode *expr, Token op) {
-	AstNode *result = make_ast_node(f, AstNode_DemaybeExpr);
-	result->DemaybeExpr.expr = expr;
-	result->DemaybeExpr.op = op;
-	return result;
-}
-
 AstNode *ast_interval_expr(AstFile *f, Token op, AstNode *left, AstNode *right) {
 	AstNode *result = make_ast_node(f, AstNode_IntervalExpr);
 
@@ -1031,13 +1017,6 @@ AstNode *ast_pointer_type(AstFile *f, Token token, AstNode *type) {
 	return result;
 }
 
-AstNode *ast_maybe_type(AstFile *f, Token token, AstNode *type) {
-	AstNode *result = make_ast_node(f, AstNode_MaybeType);
-	result->MaybeType.token = token;
-	result->MaybeType.type = type;
-	return result;
-}
-
 AstNode *ast_array_type(AstFile *f, Token token, AstNode *count, AstNode *elem) {
 	AstNode *result = make_ast_node(f, AstNode_ArrayType);
 	result->ArrayType.token = token;
@@ -1999,10 +1978,6 @@ AstNode *parse_atom_expr(AstFile *f, bool lhs) {
 			operand = ast_deref_expr(f, operand, expect_token(f, Token_Pointer));
 			break;
 
-		case Token_Maybe: // Demaybe
-			operand = ast_demaybe_expr(f, operand, expect_token(f, Token_Maybe));
-			break;
-
 		case Token_OpenBrace:
 			if (!lhs && is_literal_type(operand) && f->expr_level >= 0) {
 				operand = parse_literal_value(f, operand);
@@ -2565,12 +2540,6 @@ AstNode *parse_type_or_ident(AstFile *f) {
 		return ast_pointer_type(f, token, elem);
 	}
 
-	case Token_Maybe: {
-		Token token = expect_token(f, Token_Maybe);
-		AstNode *elem = parse_type(f);
-		return ast_maybe_type(f, token, elem);
-	}
-
 	case Token_OpenBracket: {
 		Token token = expect_token(f, Token_OpenBracket);
 		AstNode *count_expr = NULL;

src/tokenizer.c

@@ -17,7 +17,7 @@ TOKEN_KIND(Token__OperatorBegin, "_OperatorBegin"), \
 	TOKEN_KIND(Token_Hash,    "#"), \
 	TOKEN_KIND(Token_At,      "@"), \
 	TOKEN_KIND(Token_Pointer, "^"), \
-	TOKEN_KIND(Token_Maybe,   "?"), \
+	/* TOKEN_KIND(Token_Maybe,   "?"), */ \
 	TOKEN_KIND(Token_Add,     "+"), \
 	TOKEN_KIND(Token_Sub,     "-"), \
 	TOKEN_KIND(Token_Mul,     "*"), \
@@ -55,6 +55,8 @@ TOKEN_KIND(Token__AssignOpBegin, "_AssignOpBegin"), \
 TOKEN_KIND(Token__AssignOpEnd,   "_AssignOpEnd"), \
 	TOKEN_KIND(Token_ArrowRight, "->"), \
 	TOKEN_KIND(Token_ArrowLeft,  "<-"), \
+	TOKEN_KIND(Token_Increment,  "++"), \
+	TOKEN_KIND(Token_Decrement,  "--"), \
 \
 TOKEN_KIND(Token__ComparisonBegin, "_ComparisonBegin"), \
 	TOKEN_KIND(Token_CmpEq, "=="), \
@@ -80,7 +82,7 @@ TOKEN_KIND(Token__ComparisonEnd, "_ComparisonEnd"), \
 TOKEN_KIND(Token__OperatorEnd, "_OperatorEnd"), \
 \
 TOKEN_KIND(Token__KeywordBegin, "_KeywordBegin"), \
-	/* TODO(bill): So of these keywords are not used but "reserved", why not remove them? */ \
+	/* TODO(bill): Of these keywords are not used but "reserved", why not remove them? */ \
 	TOKEN_KIND(Token_when,           "when"), \
 	TOKEN_KIND(Token_if,             "if"), \
 	TOKEN_KIND(Token_else,           "else"), \
@@ -870,9 +872,9 @@ Token tokenizer_get_token(Tokenizer *t) {
 		case '^':
 			token.kind = Token_Pointer;
 			break;
-		case '?':
+		// case '?':
-			token.kind = Token_Maybe;
+			// token.kind = Token_Maybe;
-			break;
+			// break;
 		case ';':
 			token.kind = Token_Semicolon;
 			break;
@@ -907,10 +909,10 @@ Token tokenizer_get_token(Tokenizer *t) {
 		case '~': token.kind = token_kind_variant2(t, Token_Xor,   Token_XorEq);     break;
 		case '!': token.kind = token_kind_variant2(t, Token_Not,   Token_NotEq);     break;
 		case '+':
-			token.kind = token_kind_variant2(t, Token_Add, Token_AddEq);
+			token.kind = token_kind_variant3(t, Token_Add, Token_AddEq, '+', Token_Increment);
 			break;
 		case '-':
-			token.kind = token_kind_variant3(t, Token_Sub, Token_SubEq, '>', Token_ArrowRight);
+			token.kind = token_kind_variant4(t, Token_Sub, Token_SubEq, '-', Token_Decrement, '>', Token_ArrowRight);
 			break;
 		case '/': {
 			if (t->curr_rune == '/') {

src/types.c

@@ -11,6 +11,20 @@ typedef enum BasicKind {
 	Basic_u32,
 	Basic_i64,
 	Basic_u64,
+
+/* 	Basic_i16le,
+	Basic_i16be,
+	Basic_u16le,
+	Basic_u16be,
+	Basic_i32le,
+	Basic_i32be,
+	Basic_u32le,
+	Basic_u32be,
+	Basic_i64le,
+	Basic_i64be,
+	Basic_u64le,
+	Basic_u64be, */
+
 	// Basic_i128,
 	// Basic_u128,
 	// Basic_f16,
@@ -93,6 +107,7 @@ typedef struct TypeRecord {
 	Entity * enum_count;
 	Entity * enum_min_value;
 	Entity * enum_max_value;
+	Entity * enum_names;
 } TypeRecord;
 
 #define TYPE_KINDS                                        \
@@ -102,7 +117,6 @@ typedef struct TypeRecord {
 	TYPE_KIND(DynamicArray, struct { Type *elem; })       \
 	TYPE_KIND(Vector,  struct { Type *elem; i64 count; }) \
 	TYPE_KIND(Slice,   struct { Type *elem; })            \
-	TYPE_KIND(Maybe,   struct { Type *elem; })            \
 	TYPE_KIND(Record,  TypeRecord)                        \
 	TYPE_KIND(Named, struct {                             \
 		String  name;                                     \
@@ -177,16 +191,16 @@ typedef struct BaseTypeSizes {
 } BaseTypeSizes;
 
 
-typedef Array(isize) Array_isize;
+typedef Array(i32) Array_i32;
 
 typedef struct Selection {
-	Entity *    entity;
+	Entity *  entity;
-	Array_isize index;
+	Array_i32 index;
-	bool        indirect; // Set if there was a pointer deref anywhere down the line
+	bool      indirect; // Set if there was a pointer deref anywhere down the line
 } Selection;
 Selection empty_selection = {0};
 
-Selection make_selection(Entity *entity, Array_isize index, bool indirect) {
+Selection make_selection(Entity *entity, Array_i32 index, bool indirect) {
 	Selection s = {entity, index, indirect};
 	return s;
 }
@@ -273,6 +287,7 @@ gb_global Type *t_int_ptr = NULL;
 gb_global Type *t_i64_ptr = NULL;
 gb_global Type *t_f64_ptr = NULL;
 gb_global Type *t_byte_slice = NULL;
+gb_global Type *t_string_slice = NULL;
 
 
 gb_global Type *t_type_info                = NULL;
@@ -289,7 +304,6 @@ gb_global Type *t_type_info_any           = NULL;
 gb_global Type *t_type_info_string        = NULL;
 gb_global Type *t_type_info_boolean       = NULL;
 gb_global Type *t_type_info_pointer       = NULL;
-gb_global Type *t_type_info_maybe         = NULL;
 gb_global Type *t_type_info_procedure     = NULL;
 gb_global Type *t_type_info_array         = NULL;
 gb_global Type *t_type_info_dynamic_array = NULL;
@@ -310,7 +324,6 @@ gb_global Type *t_type_info_any_ptr           = NULL;
 gb_global Type *t_type_info_string_ptr        = NULL;
 gb_global Type *t_type_info_boolean_ptr       = NULL;
 gb_global Type *t_type_info_pointer_ptr       = NULL;
-gb_global Type *t_type_info_maybe_ptr         = NULL;
 gb_global Type *t_type_info_procedure_ptr     = NULL;
 gb_global Type *t_type_info_array_ptr         = NULL;
 gb_global Type *t_type_info_dynamic_array_ptr = NULL;
@@ -393,12 +406,6 @@ Type *make_type_pointer(gbAllocator a, Type *elem) {
 	return t;
 }
 
-Type *make_type_maybe(gbAllocator a, Type *elem) {
-	Type *t = alloc_type(a, Type_Maybe);
-	t->Maybe.elem = elem;
-	return t;
-}
-
 Type *make_type_array(gbAllocator a, Type *elem, i64 count) {
 	Type *t = alloc_type(a, Type_Array);
 	t->Array.elem = elem;
@@ -630,10 +637,6 @@ bool is_type_pointer(Type *t) {
 	}
 	return t->kind == Type_Pointer;
 }
-bool is_type_maybe(Type *t) {
-	t = base_type(t);
-	return t->kind == Type_Maybe;
-}
 bool is_type_tuple(Type *t) {
 	t = base_type(t);
 	return t->kind == Type_Tuple;
@@ -780,7 +783,6 @@ bool type_has_nil(Type *t) {
 	case Type_DynamicArray:
 	case Type_Proc:
 	case Type_Pointer:
-	case Type_Maybe:
 		return true;
 	}
 	return false;
@@ -890,12 +892,6 @@ bool are_types_identical(Type *x, Type *y) {
 		}
 		break;
 
-	case Type_Maybe:
-		if (y->kind == Type_Maybe) {
-			return are_types_identical(x->Maybe.elem, y->Maybe.elem);
-		}
-		break;
-
 	case Type_Named:
 		if (y->kind == Type_Named) {
 			return x->Named.base == y->Named.base;
@@ -981,9 +977,6 @@ bool is_type_cte_safe(Type *type) {
 	case Type_Slice:
 		return false;
 
-	case Type_Maybe:
-		return is_type_cte_safe(type->Maybe.elem);
-
 	case Type_Record: {
 		if (type->Record.kind != TypeRecord_Struct) {
 			return false;
@@ -1026,12 +1019,14 @@ typedef enum ProcTypeOverloadKind {
 	ProcOverload_ResultCount,
 	ProcOverload_ResultTypes,
 
+	ProcOverload_NotProcedure,
+
 } ProcTypeOverloadKind;
 
 
 ProcTypeOverloadKind are_proc_types_overload_safe(Type *x, Type *y) {
-	GB_ASSERT(is_type_proc(x));
+ 	if (!is_type_proc(x)) return ProcOverload_NotProcedure;
-	GB_ASSERT(is_type_proc(y));
+ 	if (!is_type_proc(y)) return ProcOverload_NotProcedure;
 	TypeProc *px = &base_type(x)->Proc;
 	TypeProc *py = &base_type(y)->Proc;
 
@@ -1113,7 +1108,7 @@ Selection lookup_field_from_index(gbAllocator a, Type *type, i64 index) {
 			Entity *f = type->Record.fields[i];
 			if (f->kind == Entity_Variable) {
 				if (f->Variable.field_src_index == index) {
-					Array_isize sel_array = {0};
+					Array_i32 sel_array = {0};
 					array_init_count(&sel_array, a, 1);
 					sel_array.e[0] = i;
 					return make_selection(f, sel_array, false);
@@ -1125,7 +1120,7 @@ Selection lookup_field_from_index(gbAllocator a, Type *type, i64 index) {
 		for (isize i = 0; i < max_count; i++) {
 			Entity *f = type->Tuple.variables[i];
 			if (i == index) {
-				Array_isize sel_array = {0};
+				Array_i32 sel_array = {0};
 				array_init_count(&sel_array, a, 1);
 				sel_array.e[0] = i;
 				return make_selection(f, sel_array, false);
@@ -1352,6 +1347,10 @@ Selection lookup_field_with_selection(gbAllocator a, Type *type_, String field_n
 					sel.entity = type->Record.enum_max_value;
 					return sel;
 				}
+				if (str_eq(field_name, str_lit("names"))) {
+					sel.entity = type->Record.enum_names;
+					return sel;
+				}
 			}
 
 			for (isize i = 0; i < type->Record.field_count; i++) {
@@ -1558,17 +1557,6 @@ i64 type_align_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, Type
 		return max;
 	} break;
 
-	case Type_Maybe: {
-		Type *elem = t->Maybe.elem;
-		type_path_push(path, elem);
-		if (path->failure) {
-			return FAILURE_ALIGNMENT;
-		}
-		i64 align = gb_max(type_align_of_internal(s, allocator, t->Maybe.elem, path), type_align_of_internal(s, allocator, t_bool, path));
-		type_path_pop(path);
-		return align;
-	}
-
 	case Type_Map: {
 		if (t->Map.count == 0) { // Dynamic
 			return type_align_of_internal(s, allocator, t->Map.generated_struct_type, path);
@@ -1773,18 +1761,6 @@ i64 type_size_of_internal(BaseTypeSizes s, gbAllocator allocator, Type *t, TypeP
 	case Type_Slice: // ptr + count
 		return 2 * s.word_size;
 
-	case Type_Maybe: { // value + bool
-		i64 align, size;
-		Type *elem = t->Maybe.elem;
-		align = type_align_of_internal(s, allocator, elem, path);
-		if (path->failure) {
-			return FAILURE_SIZE;
-		}
-		size = align_formula(type_size_of_internal(s, allocator, elem, path), align);
-		size += type_size_of_internal(s, allocator, t_bool, path);
-		return align_formula(size, align);
-	}
-
 	case Type_Map: {
 		if (t->Map.count == 0) { // Dynamic
 			return type_size_of_internal(s, allocator, t->Map.generated_struct_type, path);
@@ -1969,11 +1945,6 @@ gbString write_type_to_string(gbString str, Type *type) {
 		str = write_type_to_string(str, type->Pointer.elem);
 		break;
 
-	case Type_Maybe:
-		str = gb_string_appendc(str, "?");
-		str = write_type_to_string(str, type->Maybe.elem);
-		break;
-
 	case Type_Array:
 		str = gb_string_appendc(str, gb_bprintf("[%lld]", type->Array.count));
 		str = write_type_to_string(str, type->Array.elem);