Remove need for `type` keyword

11 files changed, 195 insertions, 220 deletions

diff --git a/code/http_test.odin b/code/http_test.odin
index e6c5f1173..ca76e1c55 100644
--- a/code/http_test.odin
+++ b/code/http_test.odin
@@ -3,7 +3,7 @@
 #foreign_system_library ws2 "Ws2_32.lib" when ODIN_OS == "windows";
 
 
-SOCKET :: type uint;
+SOCKET :: #type uint;
 INVALID_SOCKET :: ~(cast(SOCKET)0);
 
 AF :: enum i32 {
diff --git a/core/_preload.odin b/core/_preload.odin
index d9b93a2c6..802fc3801 100644
--- a/core/_preload.odin
+++ b/core/_preload.odin
@@ -109,7 +109,7 @@ type_info_base :: proc(info: ^Type_Info) -> ^Type_Info {
 		return nil;
 	}
 	base := info;
-	match type i in base {
+	match i in base {
 	case Type_Info.Named:
 		base = i.base;
 	}
@@ -122,7 +122,7 @@ type_info_base_without_enum :: proc(info: ^Type_Info) -> ^Type_Info {
 		return nil;
 	}
 	base := info;
-	match type i in base {
+	match i in base {
 	case Type_Info.Named:
 		base = i.base;
 	case Type_Info.Enum:
@@ -152,9 +152,9 @@ Allocator_Mode :: enum u8 {
 	FREE_ALL,
 	RESIZE,
 }
-Allocator_Proc :: type proc(allocator_data: rawptr, mode: Allocator_Mode,
-                            size, alignment: int,
-                            old_memory: rawptr, old_size: int, flags: u64) -> rawptr;
+Allocator_Proc :: #type proc(allocator_data: rawptr, mode: Allocator_Mode,
+                             size, alignment: int,
+                             old_memory: rawptr, old_size: int, flags: u64) -> rawptr;
 Allocator :: struct #ordered {
 	procedure: Allocator_Proc,
 	data:      rawptr,
@@ -657,7 +657,7 @@ __dynamic_map_erase :: proc(using h: __Map_Header, fr: __Map_Find_Result) {
 
 __print_ti_ptr :: proc(ti: ^Type_Info) {
 	fmt.println(ti);
-	match type e in ti {
+	match e in ti {
 	case Type_Info.Enum:
 		fmt.println(e.names);
 	}
diff --git a/core/fmt.odin b/core/fmt.odin
index 48f70b46a..caa17f77d 100644
--- a/core/fmt.odin
+++ b/core/fmt.odin
@@ -107,7 +107,7 @@ buffer_write_type :: proc(buf: ^Buffer, ti: ^Type_Info) {
 	}
 
 	using Type_Info;
-	match type info in ti {
+	match info in ti {
 	case Named:
 		buffer_write_string(buf, info.name);
 	case Integer:
@@ -355,7 +355,7 @@ int_from_arg :: proc(args: []any, arg_index: int) -> (int, int, bool) {
 	if arg_index < args.count {
 		arg := args[arg_index];
 		arg.type_info = type_info_base(arg.type_info);
-		match type i in arg {
+		match i in arg {
 		case int:  num = i;
 		case i8:   num = cast(int)i;
 		case i16:  num = cast(int)i;
@@ -645,7 +645,7 @@ fmt_enum :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
 	}
 
 	using Type_Info;
-	match type e in v.type_info {
+	match e in v.type_info {
 	default:
 		fmt_bad_verb(fi, verb);
 		return;
@@ -658,7 +658,7 @@ fmt_enum :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
 			f: f64;
 			ok := false;
 			a := any{type_info_base(e.base), v.data};
-			match type v in a {
+			match v in a {
 			case i8:   i = cast(i64)v;
 			case i16:  i = cast(i64)v;
 			case i32:  i = cast(i64)v;
@@ -709,9 +709,9 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
 	}
 
 	using Type_Info;
-	match type info in v.type_info {
+	match info in v.type_info {
 	case Named:
-		match type b in info.base {
+		match b in info.base {
 		case Struct:
 			if verb != 'v' {
 				fmt_bad_verb(fi, verb);
@@ -882,7 +882,7 @@ fmt_arg :: proc(fi: ^Fmt_Info, arg: any, verb: rune) {
 
 	if verb == 'T' {
 		ti := arg.type_info;
-		match type a in arg {
+		match a in arg {
 		case ^Type_Info: ti = a;
 		}
 		buffer_write_type(fi.buf, ti);
@@ -892,7 +892,7 @@ fmt_arg :: proc(fi: ^Fmt_Info, arg: any, verb: rune) {
 
 	base_arg := arg;
 	base_arg.type_info = type_info_base(base_arg.type_info);
-	match type a in base_arg {
+	match a in base_arg {
 	case bool:    fmt_bool(fi, a, verb);
 	case f32:     fmt_float(fi, cast(f64)a, 32, verb);
 	case f64:     fmt_float(fi, a, 64, verb);
diff --git a/core/mem.odin b/core/mem.odin
index 3bff8fc74..ce1c4a21c 100644
--- a/core/mem.odin
+++ b/core/mem.odin
@@ -217,7 +217,7 @@ 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 {
+	match info in type_info {
 	case Named:
 		return align_of_type_info(info.base);
 	case Integer:
@@ -270,7 +270,7 @@ align_formula :: proc(size, align: int) -> int {
 size_of_type_info :: proc(type_info: ^Type_Info) -> int {
 	WORD_SIZE :: size_of(int);
 	using Type_Info;
-	match type info in type_info {
+	match info in type_info {
 	case Named:
 		return size_of_type_info(info.base);
 	case Integer:
diff --git a/core/sys/windows.odin b/core/sys/windows.odin
index baa6218d4..2aca8fe1d 100644
--- a/core/sys/windows.odin
+++ b/core/sys/windows.odin
@@ -20,7 +20,7 @@ LPARAM    :: int;
 LRESULT   :: int;
 ATOM      :: i16;
 BOOL      :: i32;
-WNDPROC   :: type proc(HWND, u32, WPARAM, LPARAM) -> LRESULT #cc_c;
+WNDPROC   :: #type proc(HWND, u32, WPARAM, LPARAM) -> LRESULT #cc_c;
 
 
 INVALID_HANDLE_VALUE :: cast(HANDLE)(~cast(int)0);
@@ -359,8 +359,8 @@ PFD_DOUBLEBUFFER_DONTCARE :: 0x40000000;
 PFD_STEREO_DONTCARE       :: 0x80000000;
 
 HGLRC :: HANDLE;
-PROC  :: type proc() #cc_c;
-wglCreateContextAttribsARBType :: type proc(hdc: HDC, hshareContext: rawptr, attribList: ^i32) -> HGLRC;
+PROC  :: #type proc() #cc_c;
+wglCreateContextAttribsARBType :: #type proc(hdc: HDC, hshareContext: rawptr, attribList: ^i32) -> HGLRC;
 
 
 PIXELFORMATDESCRIPTOR :: struct #ordered {
diff --git a/core/types.odin b/core/types.odin
index e22b96c8b..5a46770d5 100644
--- a/core/types.odin
+++ b/core/types.odin
@@ -11,7 +11,7 @@ is_signed :: proc(info: ^Type_Info) -> bool {
 is_integer :: proc(info: ^Type_Info) -> bool {
 	if info == nil { return false; }
 
-	match type i in type_info_base(info) {
+	match i in type_info_base(info) {
 	case Type_Info.Integer: return true;
 	}
 	return false;
@@ -19,7 +19,7 @@ is_integer :: proc(info: ^Type_Info) -> bool {
 is_float :: proc(info: ^Type_Info) -> bool {
 	if info == nil { return false; }
 
-	match type i in type_info_base(info) {
+	match i in type_info_base(info) {
 	case Type_Info.Float: return true;
 	}
 	return false;
@@ -27,7 +27,7 @@ is_float :: proc(info: ^Type_Info) -> bool {
 is_any :: proc(info: ^Type_Info) -> bool {
 	if info == nil { return false; }
 
-	match type i in type_info_base(info) {
+	match i in type_info_base(info) {
 	case Type_Info.Any: return true;
 	}
 	return false;
@@ -35,7 +35,7 @@ is_any :: proc(info: ^Type_Info) -> bool {
 is_string :: proc(info: ^Type_Info) -> bool {
 	if info == nil { return false; }
 
-	match type i in type_info_base(info) {
+	match i in type_info_base(info) {
 	case Type_Info.String: return true;
 	}
 	return false;
@@ -43,7 +43,7 @@ is_string :: proc(info: ^Type_Info) -> bool {
 is_boolean :: proc(info: ^Type_Info) -> bool {
 	if info == nil { return false; }
 
-	match type i in type_info_base(info) {
+	match i in type_info_base(info) {
 	case Type_Info.Boolean: return true;
 	}
 	return false;
@@ -51,7 +51,7 @@ is_boolean :: proc(info: ^Type_Info) -> bool {
 is_pointer :: proc(info: ^Type_Info) -> bool {
 	if info == nil { return false; }
 
-	match type i in type_info_base(info) {
+	match i in type_info_base(info) {
 	case Type_Info.Pointer: return true;
 	}
 	return false;
@@ -59,7 +59,7 @@ is_pointer :: proc(info: ^Type_Info) -> bool {
 is_procedure :: proc(info: ^Type_Info) -> bool {
 	if info == nil { return false; }
 
-	match type i in type_info_base(info) {
+	match i in type_info_base(info) {
 	case Type_Info.Procedure: return true;
 	}
 	return false;
@@ -67,7 +67,7 @@ is_procedure :: proc(info: ^Type_Info) -> bool {
 is_array :: proc(info: ^Type_Info) -> bool {
 	if info == nil { return false; }
 
-	match type i in type_info_base(info) {
+	match i in type_info_base(info) {
 	case Type_Info.Array: return true;
 	}
 	return false;
@@ -75,7 +75,7 @@ is_array :: proc(info: ^Type_Info) -> bool {
 is_dynamic_array :: proc(info: ^Type_Info) -> bool {
 	if info == nil { return false; }
 
-	match type i in type_info_base(info) {
+	match i in type_info_base(info) {
 	case Type_Info.Dynamic_Array: return true;
 	}
 	return false;
@@ -83,7 +83,7 @@ is_dynamic_array :: proc(info: ^Type_Info) -> bool {
 is_dynamic_map :: proc(info: ^Type_Info) -> bool {
 	if info == nil { return false; }
 
-	match type i in type_info_base(info) {
+	match i in type_info_base(info) {
 	case Type_Info.Map: return i.count == 0;
 	}
 	return false;
@@ -91,7 +91,7 @@ is_dynamic_map :: proc(info: ^Type_Info) -> bool {
 is_slice :: proc(info: ^Type_Info) -> bool {
 	if info == nil { return false; }
 
-	match type i in type_info_base(info) {
+	match i in type_info_base(info) {
 	case Type_Info.Slice: return true;
 	}
 	return false;
@@ -99,7 +99,7 @@ is_slice :: proc(info: ^Type_Info) -> bool {
 is_vector :: proc(info: ^Type_Info) -> bool {
 	if info == nil { return false; }
 
-	match type i in type_info_base(info) {
+	match i in type_info_base(info) {
 	case Type_Info.Vector: return true;
 	}
 	return false;
@@ -107,7 +107,7 @@ is_vector :: proc(info: ^Type_Info) -> bool {
 is_tuple :: proc(info: ^Type_Info) -> bool {
 	if info == nil { return false; }
 
-	match type i in type_info_base(info) {
+	match i in type_info_base(info) {
 	case Type_Info.Tuple: return true;
 	}
 	return false;
@@ -115,7 +115,7 @@ is_tuple :: proc(info: ^Type_Info) -> bool {
 is_struct :: proc(info: ^Type_Info) -> bool {
 	if info == nil { return false; }
 
-	match type i in type_info_base(info) {
+	match i in type_info_base(info) {
 	case Type_Info.Struct: return true;
 	}
 	return false;
@@ -123,7 +123,7 @@ is_struct :: proc(info: ^Type_Info) -> bool {
 is_union :: proc(info: ^Type_Info) -> bool {
 	if info == nil { return false; }
 
-	match type i in type_info_base(info) {
+	match i in type_info_base(info) {
 	case Type_Info.Union: return true;
 	}
 	return false;
@@ -131,7 +131,7 @@ is_union :: proc(info: ^Type_Info) -> bool {
 is_raw_union :: proc(info: ^Type_Info) -> bool {
 	if info == nil { return false; }
 
-	match type i in type_info_base(info) {
+	match i in type_info_base(info) {
 	case Type_Info.Raw_Union: return true;
 	}
 	return false;
@@ -139,7 +139,7 @@ is_raw_union :: proc(info: ^Type_Info) -> bool {
 is_enum :: proc(info: ^Type_Info) -> bool {
 	if info == nil { return false; }
 
-	match type i in type_info_base(info) {
+	match i in type_info_base(info) {
 	case Type_Info.Enum: return true;
 	}
 	return false;
diff --git a/src/check_expr.c b/src/check_expr.c
index 3a4f57ea8..d3bc5895c 100644
--- a/src/check_expr.c
+++ b/src/check_expr.c
@@ -4766,11 +4766,12 @@ ExprKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *type_hint
 		o->expr = node;
 	case_end;
 
-
 	case_ast_node(te, TagExpr, node);
-		// TODO(bill): Tag expressions
-		error_node(node, "Tag expressions are not supported yet");
-		kind = check_expr_base(c, o, te->expr, type_hint);
+		String name = te->name.string;
+		error_node(node, "Unknown tag expression, #%.*s", LIT(name));
+		if (te->expr) {
+			kind = check_expr_base(c, o, te->expr, type_hint);
+		}
 		o->expr = node;
 	case_end;
 
diff --git a/src/check_stmt.c b/src/check_stmt.c
index 9155947fc..9067d1037 100644
--- a/src/check_stmt.c
+++ b/src/check_stmt.c
@@ -942,7 +942,25 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
 		bool is_union_ptr = false;
 		bool is_any = false;
 
-		check_expr(c, &x, ms->tag);
+		if (ms->tag->kind != AstNode_AssignStmt) {
+			error_node(ms->tag, "Expected an `in` assignment for this type match statement");
+			break;
+		}
+
+		ast_node(as, AssignStmt, ms->tag);
+		Token as_token = ast_node_token(ms->tag);
+		if (as->lhs.count != 1) {
+			syntax_error(as_token, "Expected 1 name before `in`");
+			break;
+		}
+		if (as->rhs.count != 1) {
+			syntax_error(as_token, "Expected 1 expression after `in`");
+			break;
+		}
+		AstNode *lhs = as->lhs.e[0];
+		AstNode *rhs = as->rhs.e[0];
+
+		check_expr(c, &x, rhs);
 		check_assignment(c, &x, NULL, str_lit("type match expression"));
 		if (!check_valid_type_match_type(x.type, &is_union_ptr, &is_any)) {
 			gbString str = type_to_string(x.type);
@@ -980,7 +998,9 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
 			}
 		}
 
-		if (ms->var->kind != AstNode_Ident) {
+
+		if (unparen_expr(lhs)->kind != AstNode_Ident) {
+			error_node(rhs, "Expected an identifier, got `%.*s`", LIT(ast_node_strings[rhs->kind]));
 			break;
 		}
 
@@ -1056,10 +1076,10 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
 					tt = make_type_pointer(c->allocator, case_type);
 					add_type_info_type(c, tt);
 				}
-				Entity *tag_var = make_entity_variable(c->allocator, c->context.scope, ms->var->Ident, tt, true);
+				Entity *tag_var = make_entity_variable(c->allocator, c->context.scope, lhs->Ident, tt, true);
 				tag_var->flags |= EntityFlag_Used;
-				add_entity(c, c->context.scope, ms->var, tag_var);
-				add_entity_use(c, ms->var, tag_var);
+				add_entity(c, c->context.scope, lhs, tag_var);
+				add_entity_use(c, lhs, tag_var);
 			}
 			check_stmt_list(c, cc->stmts, mod_flags);
 			check_close_scope(c);
diff --git a/src/ir.c b/src/ir.c
index 7ddcb6344..05a21d0d8 100644
--- a/src/ir.c
+++ b/src/ir.c
@@ -5255,7 +5255,13 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) {
 		ir_emit_comment(proc, str_lit("TypeMatchStmt"));
 		gbAllocator allocator = proc->module->allocator;
 
-		irValue *parent = ir_build_expr(proc, ms->tag);
+		ast_node(as, AssignStmt, ms->tag);
+		GB_ASSERT(as->lhs.count == 1);
+		GB_ASSERT(as->rhs.count == 1);
+		AstNode *lhs = as->lhs.e[0];
+		AstNode *rhs = as->rhs.e[0];
+
+		irValue *parent = ir_build_expr(proc, rhs);
 		bool is_union_ptr = false;
 		bool is_any = false;
 		GB_ASSERT(check_valid_type_match_type(ir_type(parent), &is_union_ptr, &is_any));
@@ -5276,7 +5282,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) {
 
 		ast_node(body, BlockStmt, ms->body);
 
-		String tag_var_name = ms->var->Ident.string;
+		String tag_var_name = lhs->Ident.string;
 
 
 		AstNodeArray default_stmts = {0};
diff --git a/src/parser.c b/src/parser.c
index 7531412ef..3179509e7 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -250,7 +250,6 @@ AST_NODE_KIND(_ComplexStmtBegin, "", i32) \
 	AST_NODE_KIND(TypeMatchStmt, "type match statement", struct { \
 		Token    token; \
 		AstNode *tag;   \
- 		AstNode *var;   \
 		AstNode *body;  \
 	}) \
 	AST_NODE_KIND(DeferStmt,  "defer statement",  struct { Token token; AstNode *stmt; }) \
@@ -893,11 +892,10 @@ AstNode *ast_match_stmt(AstFile *f, Token token, AstNode *init, AstNode *tag, As
 }
 
 
-AstNode *ast_type_match_stmt(AstFile *f, Token token, AstNode *tag, AstNode *var, AstNode *body) {
+AstNode *ast_type_match_stmt(AstFile *f, Token token, AstNode *tag, AstNode *body) {
 	AstNode *result = make_ast_node(f, AstNode_TypeMatchStmt);
 	result->TypeMatchStmt.token = token;
 	result->TypeMatchStmt.tag   = tag;
-	result->TypeMatchStmt.var   = var;
 	result->TypeMatchStmt.body  = body;
 	return result;
 }
@@ -1756,6 +1754,7 @@ AstNode *parse_operand(AstFile *f, bool lhs) {
 		} else if (str_eq(name.string, str_lit("file"))) { return ast_basic_directive(f, token, name.string);
 		} else if (str_eq(name.string, str_lit("line"))) { return ast_basic_directive(f, token, name.string);
 		} else if (str_eq(name.string, str_lit("procedure"))) { return ast_basic_directive(f, token, name.string);
+		} else if (str_eq(name.string, str_lit("type"))) { return ast_helper_type(f, token, parse_type(f));
 		} else {
 			operand = ast_tag_expr(f, token, name, parse_expr(f, false));
 		}
@@ -2180,9 +2179,7 @@ AstNode *parse_value_decl(AstFile *f, AstNodeArray lhs) {
 	bool is_mutable = true;
 
 	if (allow_token(f, Token_Colon)) {
-		if (!allow_token(f, Token_type)) {
-			type = parse_type_attempt(f);
-		}
+		type = parse_type_attempt(f);
 	} else if (f->curr_token.kind != Token_Eq &&
 	           f->curr_token.kind != Token_Semicolon) {
 		syntax_error(f->curr_token, "Expected a type separator `:` or `=`");
@@ -2528,10 +2525,16 @@ AstNode *parse_type_or_ident(AstFile *f) {
 		return e;
 	}
 
-	case Token_type: {
-		Token token = expect_token(f, Token_type);
-		AstNode *type = parse_type(f);
-		return ast_helper_type(f, token, type);
+	case Token_Hash: {
+		Token hash_token = expect_token(f, Token_Hash);
+		Token name = expect_token(f, Token_Ident);
+		String tag = name.string;
+		if (str_eq(tag, str_lit("type"))) {
+			AstNode *type = parse_type(f);
+			return ast_helper_type(f, hash_token, type);
+		}
+		syntax_error(name, "Expected `type` after #");
+		return ast_bad_expr(f, hash_token, f->curr_token);
 	}
 
 	case Token_Pointer: {
@@ -2941,8 +2944,7 @@ AstNode *parse_for_stmt(AstFile *f) {
 		f->expr_level = -1;
 		if (f->curr_token.kind != Token_Semicolon) {
 			cond = parse_simple_stmt(f, true);
-			if (cond->kind == AstNode_AssignStmt &&
-			    cond->AssignStmt.op.kind == Token_in) {
+			if (cond->kind == AstNode_AssignStmt && cond->AssignStmt.op.kind == Token_in) {
 				is_range = true;
 			}
 		}
@@ -3034,6 +3036,7 @@ AstNode *parse_for_stmt(AstFile *f) {
 #endif
 }
 
+
 AstNode *parse_case_clause(AstFile *f) {
 	Token token = f->curr_token;
 	AstNodeArray list = make_ast_node_array(f);
@@ -3066,6 +3069,7 @@ AstNode *parse_type_case_clause(AstFile *f) {
 }
 
 
+
 AstNode *parse_match_stmt(AstFile *f) {
 	if (f->curr_proc == NULL) {
 		syntax_error(f->curr_token, "You cannot use a match statement in the file scope");
@@ -3077,37 +3081,16 @@ AstNode *parse_match_stmt(AstFile *f) {
 	AstNode *tag  = NULL;
 	AstNode *body = NULL;
 	Token open, close;
+	bool is_type_match = false;
 
-	if (allow_token(f, Token_type)) {
+	if (f->curr_token.kind != Token_OpenBrace) {
 		isize prev_level = f->expr_level;
 		f->expr_level = -1;
 
-		AstNode *var = parse_ident(f);
-		expect_token_after(f, Token_in, "match type name");
-		tag = parse_simple_stmt(f, false);
-
-		f->expr_level = prev_level;
-
-		open = expect_token(f, Token_OpenBrace);
-		AstNodeArray list = make_ast_node_array(f);
-
-		while (f->curr_token.kind == Token_case ||
-		       f->curr_token.kind == Token_default) {
-			array_add(&list, parse_type_case_clause(f));
-		}
-
-		close = expect_token(f, Token_CloseBrace);
-		body = ast_block_stmt(f, list, open, close);
-
-		tag = convert_stmt_to_expr(f, tag, str_lit("type match expression"));
-		return ast_type_match_stmt(f, token, tag, var, body);
-	} else {
-		if (f->curr_token.kind != Token_OpenBrace) {
-			isize prev_level = f->expr_level;
-			f->expr_level = -1;
-			if (f->curr_token.kind != Token_Semicolon) {
-				tag = parse_simple_stmt(f, false);
-			}
+		tag = parse_simple_stmt(f, true);
+		if (tag->kind == AstNode_AssignStmt && tag->AssignStmt.op.kind == Token_in) {
+			is_type_match = true;
+		} else {
 			if (allow_token(f, Token_Semicolon)) {
 				init = tag;
 				tag = NULL;
@@ -3115,28 +3098,33 @@ AstNode *parse_match_stmt(AstFile *f) {
 					tag = parse_simple_stmt(f, false);
 				}
 			}
-
-			f->expr_level = prev_level;
 		}
+		f->expr_level = prev_level;
+	}
+	open = expect_token(f, Token_OpenBrace);
+	AstNodeArray list = make_ast_node_array(f);
 
-		open = expect_token(f, Token_OpenBrace);
-		AstNodeArray list = make_ast_node_array(f);
-
-		while (f->curr_token.kind == Token_case ||
-		       f->curr_token.kind == Token_default) {
+	while (f->curr_token.kind == Token_case ||
+	       f->curr_token.kind == Token_default) {
+		if (is_type_match) {
+			array_add(&list, parse_type_case_clause(f));
+		} else {
 			array_add(&list, parse_case_clause(f));
 		}
+	}
 
-		close = expect_token(f, Token_CloseBrace);
+	close = expect_token(f, Token_CloseBrace);
 
-		body = ast_block_stmt(f, list, open, close);
+	body = ast_block_stmt(f, list, open, close);
 
+	if (!is_type_match) {
 		tag = convert_stmt_to_expr(f, tag, str_lit("match expression"));
 		return ast_match_stmt(f, token, init, tag, body);
+	} else {
+		return ast_type_match_stmt(f, token, tag, body);
 	}
 }
 
-
 AstNode *parse_defer_stmt(AstFile *f) {
 	if (f->curr_proc == NULL) {
 		syntax_error(f->curr_token, "You cannot use a defer statement in the file scope");
@@ -3328,6 +3316,7 @@ AstNode *parse_stmt(AstFile *f) {
 		Token hash_token = expect_token(f, Token_Hash);
 		Token name = expect_token(f, Token_Ident);
 		String tag = name.string;
+
 		if (str_eq(tag, str_lit("import"))) {
 			AstNode *cond = NULL;
 			Token import_name = {0};
diff --git a/src/tokenizer.c b/src/tokenizer.c
index 308224157..92256f021 100644
--- a/src/tokenizer.c
+++ b/src/tokenizer.c
@@ -12,23 +12,24 @@ TOKEN_KIND(Token__LiteralBegin, "_LiteralBegin"), \
 TOKEN_KIND(Token__LiteralEnd,   "_LiteralEnd"), \
 \
 TOKEN_KIND(Token__OperatorBegin, "_OperatorBegin"), \
-	TOKEN_KIND(Token_Eq,      "="), \
-	TOKEN_KIND(Token_Not,     "!"), \
-	TOKEN_KIND(Token_Hash,    "#"), \
-	TOKEN_KIND(Token_At,      "@"), \
-	TOKEN_KIND(Token_Pointer, "^"), \
-	/* TOKEN_KIND(Token_Maybe,   "?"), */ \
-	TOKEN_KIND(Token_Add,     "+"), \
-	TOKEN_KIND(Token_Sub,     "-"), \
-	TOKEN_KIND(Token_Mul,     "*"), \
-	TOKEN_KIND(Token_Quo,     "/"), \
-	TOKEN_KIND(Token_Mod,     "%"), \
-	TOKEN_KIND(Token_And,     "&"), \
-	TOKEN_KIND(Token_Or,      "|"), \
-	TOKEN_KIND(Token_Xor,     "~"), \
-	TOKEN_KIND(Token_AndNot,  "&~"), \
-	TOKEN_KIND(Token_Shl,     "<<"), \
-	TOKEN_KIND(Token_Shr,     ">>"), \
+	TOKEN_KIND(Token_Eq,       "="), \
+	TOKEN_KIND(Token_Not,      "!"), \
+	TOKEN_KIND(Token_Hash,     "#"), \
+	TOKEN_KIND(Token_At,       "@"), \
+	TOKEN_KIND(Token_Dollar,   "$"), \
+	TOKEN_KIND(Token_Pointer,  "^"), \
+	TOKEN_KIND(Token_Question, "?"), \
+	TOKEN_KIND(Token_Add,      "+"), \
+	TOKEN_KIND(Token_Sub,      "-"), \
+	TOKEN_KIND(Token_Mul,      "*"), \
+	TOKEN_KIND(Token_Quo,      "/"), \
+	TOKEN_KIND(Token_Mod,      "%"), \
+	TOKEN_KIND(Token_And,      "&"), \
+	TOKEN_KIND(Token_Or,       "|"), \
+	TOKEN_KIND(Token_Xor,      "~"), \
+	TOKEN_KIND(Token_AndNot,   "&~"), \
+	TOKEN_KIND(Token_Shl,      "<<"), \
+	TOKEN_KIND(Token_Shr,      ">>"), \
 \
 	/*TOKEN_KIND(Token_as,         "as"), */\
 	/*TOKEN_KIND(Token_transmute,  "transmute"), */\
@@ -83,44 +84,44 @@ TOKEN_KIND(Token__OperatorEnd, "_OperatorEnd"), \
 \
 TOKEN_KIND(Token__KeywordBegin, "_KeywordBegin"), \
 	/* 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"), \
-	TOKEN_KIND(Token_for,            "for"), \
-	TOKEN_KIND(Token_in,             "in"), \
-	TOKEN_KIND(Token_break,          "break"), \
-	TOKEN_KIND(Token_continue,       "continue"), \
-	TOKEN_KIND(Token_fallthrough,    "fallthrough"), \
-	TOKEN_KIND(Token_match,          "match"), \
-	TOKEN_KIND(Token_type,           "type"), \
-	TOKEN_KIND(Token_default,        "default"), \
-	TOKEN_KIND(Token_case,           "case"), \
-	TOKEN_KIND(Token_defer,          "defer"), \
-	TOKEN_KIND(Token_return,         "return"), \
-	TOKEN_KIND(Token_give,           "give"), \
-	TOKEN_KIND(Token_proc,           "proc"), \
-	TOKEN_KIND(Token_macro,          "macro"), \
-	TOKEN_KIND(Token_struct,         "struct"), \
-	TOKEN_KIND(Token_union,          "union"), \
-	TOKEN_KIND(Token_raw_union,      "raw_union"), \
-	TOKEN_KIND(Token_enum,           "enum"), \
-	TOKEN_KIND(Token_vector,         "vector"), \
-	TOKEN_KIND(Token_map,            "map"), \
-	TOKEN_KIND(Token_static,         "static"), \
-	TOKEN_KIND(Token_dynamic,        "dynamic"), \
-	TOKEN_KIND(Token_using,          "using"), \
-	TOKEN_KIND(Token_no_alias,       "no_alias"), \
-	/* TOKEN_KIND(Token_mutable,        "mutable"),  */\
+	TOKEN_KIND(Token_when,           "when"),            \
+	TOKEN_KIND(Token_if,             "if"),              \
+	TOKEN_KIND(Token_else,           "else"),            \
+	TOKEN_KIND(Token_for,            "for"),             \
+	TOKEN_KIND(Token_in,             "in"),              \
+	TOKEN_KIND(Token_break,          "break"),           \
+	TOKEN_KIND(Token_continue,       "continue"),        \
+	TOKEN_KIND(Token_fallthrough,    "fallthrough"),     \
+	TOKEN_KIND(Token_match,          "match"),           \
+	/* TOKEN_KIND(Token_type,           "type"), */      \
+	TOKEN_KIND(Token_default,        "default"),         \
+	TOKEN_KIND(Token_case,           "case"),            \
+	TOKEN_KIND(Token_defer,          "defer"),           \
+	TOKEN_KIND(Token_return,         "return"),          \
+	TOKEN_KIND(Token_give,           "give"),            \
+	TOKEN_KIND(Token_proc,           "proc"),            \
+	TOKEN_KIND(Token_macro,          "macro"),           \
+	TOKEN_KIND(Token_struct,         "struct"),          \
+	TOKEN_KIND(Token_union,          "union"),           \
+	TOKEN_KIND(Token_raw_union,      "raw_union"),       \
+	TOKEN_KIND(Token_enum,           "enum"),            \
+	TOKEN_KIND(Token_vector,         "vector"),          \
+	TOKEN_KIND(Token_map,            "map"),             \
+	TOKEN_KIND(Token_static,         "static"),          \
+	TOKEN_KIND(Token_dynamic,        "dynamic"),         \
+	TOKEN_KIND(Token_using,          "using"),           \
+	TOKEN_KIND(Token_no_alias,       "no_alias"),        \
+	/* TOKEN_KIND(Token_mutable,        "mutable"),  */  \
 	/* TOKEN_KIND(Token_immutable,      "immutable"),  */\
-	TOKEN_KIND(Token_thread_local,   "thread_local"), \
-	TOKEN_KIND(Token_cast,           "cast"), \
-	TOKEN_KIND(Token_transmute,      "transmute"), \
-	TOKEN_KIND(Token_down_cast,      "down_cast"), \
-	TOKEN_KIND(Token_union_cast,     "union_cast"), \
-	TOKEN_KIND(Token_context,        "context"), \
-	TOKEN_KIND(Token_push_context,   "push_context"), \
-	TOKEN_KIND(Token_push_allocator, "push_allocator"), \
-	TOKEN_KIND(Token_asm,            "asm"), \
+	TOKEN_KIND(Token_thread_local,   "thread_local"),    \
+	TOKEN_KIND(Token_cast,           "cast"),            \
+	TOKEN_KIND(Token_transmute,      "transmute"),       \
+	TOKEN_KIND(Token_down_cast,      "down_cast"),       \
+	TOKEN_KIND(Token_union_cast,     "union_cast"),      \
+	TOKEN_KIND(Token_context,        "context"),         \
+	TOKEN_KIND(Token_push_context,   "push_context"),    \
+	TOKEN_KIND(Token_push_allocator, "push_allocator"),  \
+	TOKEN_KIND(Token_asm,            "asm"),             \
 TOKEN_KIND(Token__KeywordEnd, "_KeywordEnd"), \
 	TOKEN_KIND(Token_Count, "")
 
@@ -480,7 +481,6 @@ gb_inline void scan_mantissa(Tokenizer *t, i32 base, bool allow_underscore) {
 	}
 }
 
-
 Token scan_number_to_token(Tokenizer *t, bool seen_decimal_point) {
 	Token token = {0};
 	token.kind = Token_Integer;
@@ -736,20 +736,10 @@ Token tokenizer_get_token(Tokenizer *t) {
 
 		// NOTE(bill): All keywords are > 1
 		if (token.string.len > 1) {
-			/* if (str_eq(token.string, token_strings[Token_as])) {
-				token.kind = Token_as;
-			} else if (str_eq(token.string, token_strings[Token_transmute])) {
-				token.kind = Token_transmute;
-			} else if (str_eq(token.string, token_strings[Token_down_cast])) {
-				token.kind = Token_down_cast;
-			} else if (str_eq(token.string, token_strings[Token_union_cast])) {
-				token.kind = Token_union_cast;
-			} else  */{
-				for (i32 k = Token__KeywordBegin+1; k < Token__KeywordEnd; k++) {
-					if (str_eq(token.string, token_strings[k])) {
-						token.kind = cast(TokenKind)k;
-						break;
-					}
+			for (i32 k = Token__KeywordBegin+1; k < Token__KeywordEnd; k++) {
+				if (str_eq(token.string, token_strings[k])) {
+					token.kind = cast(TokenKind)k;
+					break;
 				}
 			}
 		}
@@ -863,57 +853,28 @@ Token tokenizer_get_token(Tokenizer *t) {
 			}
 			break;
 
-		case '#':
-			token.kind = Token_Hash;
-			break;
-		case '@':
-			token.kind = Token_At;
-			break;
-		case '^':
-			token.kind = Token_Pointer;
-			break;
-		// case '?':
-			// token.kind = Token_Maybe;
-			// break;
-		case ';':
-			token.kind = Token_Semicolon;
-			break;
-		case ',':
-			token.kind = Token_Comma;
-			break;
-		case ':':
-			token.kind = Token_Colon;
-			break;
-		case '(':
-			token.kind = Token_OpenParen;
-			break;
-		case ')':
-			token.kind = Token_CloseParen;
-			break;
-		case '[':
-			token.kind = Token_OpenBracket;
-			break;
-		case ']':
-			token.kind = Token_CloseBracket;
-			break;
-		case '{':
-			token.kind = Token_OpenBrace;
-			break;
-		case '}':
-			token.kind = Token_CloseBrace;
-			break;
-
-		case '*': token.kind = token_kind_variant2(t, Token_Mul,   Token_MulEq);     break;
-		case '%': token.kind = token_kind_variant2(t, Token_Mod,   Token_ModEq);     break;
-		case '=': token.kind = token_kind_variant2(t, Token_Eq,    Token_CmpEq);     break;
-		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_variant3(t, Token_Add, Token_AddEq, '+', Token_Increment);
-			break;
-		case '-':
-			token.kind = token_kind_variant4(t, Token_Sub, Token_SubEq, '-', Token_Decrement, '>', Token_ArrowRight);
-			break;
+		case '#': token.kind = Token_Hash;         break;
+		case '@': token.kind = Token_At;           break;
+		case '$': token.kind = Token_Dollar;       break;
+		case '?': token.kind = Token_Question;     break;
+		case '^': token.kind = Token_Pointer;      break;
+		case ';': token.kind = Token_Semicolon;    break;
+		case ',': token.kind = Token_Comma;        break;
+		case ':': token.kind = Token_Colon;        break;
+		case '(': token.kind = Token_OpenParen;    break;
+		case ')': token.kind = Token_CloseParen;   break;
+		case '[': token.kind = Token_OpenBracket;  break;
+		case ']': token.kind = Token_CloseBracket; break;
+		case '{': token.kind = Token_OpenBrace;    break;
+		case '}': token.kind = Token_CloseBrace;   break;
+
+		case '*': token.kind = token_kind_variant2(t, Token_Mul, Token_MulEq);                                              break;
+		case '%': token.kind = token_kind_variant2(t, Token_Mod, Token_ModEq);                                              break;
+		case '=': token.kind = token_kind_variant2(t, Token_Eq,  Token_CmpEq);                                              break;
+		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_variant3(t, Token_Add, Token_AddEq, '+', Token_Increment);                        break;
+		case '-': token.kind = token_kind_variant4(t, Token_Sub, Token_SubEq, '-', Token_Decrement, '>', Token_ArrowRight); break;
 		case '/': {
 			if (t->curr_rune == '/') {
 				while (t->curr_rune != '\n' && t->curr_rune != GB_RUNE_EOF) {
@@ -953,9 +914,7 @@ Token tokenizer_get_token(Tokenizer *t) {
 				token.kind = token_kind_dub_eq(t, '<', Token_Lt, Token_LtEq, Token_Shl, Token_ShlEq);
 			}
 			break;
-		case '>':
-			token.kind = token_kind_dub_eq(t, '>', Token_Gt, Token_GtEq, Token_Shr, Token_ShrEq);
-			break;
+		case '>': token.kind = token_kind_dub_eq(t, '>', Token_Gt, Token_GtEq, Token_Shr, Token_ShrEq); break;
 
 		case '&':
 			token.kind = Token_And;