Change cast syntax, int(x), []byte(s), (^int)(p)

src/check_expr.c

@@ -1911,6 +1911,7 @@ void check_binary_expr(Checker *c, Operand *x, AstNode *node) {
 
 	ast_node(be, BinaryExpr, node);
 
+#if 0
 	switch (be->op.kind) {
 	case Token_as: {
 		check_expr(c, x, be->left);
@@ -2103,7 +2104,7 @@ void check_binary_expr(Checker *c, Operand *x, AstNode *node) {
 		return;
 	} break;
 	}
-
+#endif
 	check_expr(c, x, be->left);
 	check_expr(c, y, be->right);
 	if (x->mode == Addressing_Invalid) {
@@ -2728,6 +2729,10 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 	case BuiltinProc_align_of:
 	case BuiltinProc_offset_of:
 	case BuiltinProc_type_info:
+
+	case BuiltinProc_transmute:
+	case BuiltinProc_union_cast:
+	case BuiltinProc_down_cast:
 		// NOTE(bill): The first arg may be a Type, this will be checked case by case
 		break;
 	default:
@@ -2925,6 +2930,10 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		if (operand->mode == Addressing_Invalid || operand->mode == Addressing_Builtin) {
 			return false;
 		}
+		if (operand->type == NULL || operand->type == t_invalid) {
+			error_node(operand->expr, "Invalid argument to `type_of_val`");
+			return false;
+		}
 		operand->mode = Addressing_Type;
 		break;
 
@@ -2969,6 +2978,184 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 	} break;
 
 
+	case BuiltinProc_transmute: {
+		Type *type = check_type(c, ce->args.e[0]);
+		check_expr(c, operand, ce->args.e[1]);
+		if (operand->mode == Addressing_Invalid) {
+			return false;
+		}
+
+		if (operand->mode == Addressing_Constant) {
+			gbString expr_str = expr_to_string(operand->expr);
+			error_node(operand->expr, "Cannot transmute constant expression: `%s`", expr_str);
+			gb_string_free(expr_str);
+			operand->mode = Addressing_Invalid;
+			return false;
+		}
+
+		if (is_type_untyped(operand->type)) {
+			gbString expr_str = expr_to_string(operand->expr);
+			error_node(operand->expr, "Cannot transmute untyped expression: `%s`", expr_str);
+			gb_string_free(expr_str);
+			operand->mode = Addressing_Invalid;
+			return false;
+		}
+
+		i64 srcz = type_size_of(c->sizes, c->allocator, operand->type);
+		i64 dstz = type_size_of(c->sizes, c->allocator, type);
+		if (srcz != dstz) {
+			gbString expr_str = expr_to_string(operand->expr);
+			gbString type_str = type_to_string(type);
+			error_node(operand->expr, "Cannot transmute `%s` to `%s`, %lld vs %lld bytes", expr_str, type_str, srcz, dstz);
+			gb_string_free(type_str);
+			gb_string_free(expr_str);
+			operand->mode = Addressing_Invalid;
+			return false;
+		}
+
+		operand->type = type;
+	} break;
+	case BuiltinProc_union_cast: {
+		Type *type = check_type(c, ce->args.e[0]);
+		check_expr(c, operand, ce->args.e[1]);
+		if (operand->mode == Addressing_Invalid) {
+			return false;
+		}
+
+		if (operand->mode == Addressing_Constant) {
+			gbString expr_str = expr_to_string(operand->expr);
+			error_node(operand->expr, "Cannot `union_cast` a constant expression: `%s`", expr_str);
+			gb_string_free(expr_str);
+			operand->mode = Addressing_Invalid;
+			return false;
+		}
+
+		if (is_type_untyped(operand->type)) {
+			gbString expr_str = expr_to_string(operand->expr);
+			error_node(operand->expr, "Cannot `union_cast` an untyped expression: `%s`", expr_str);
+			gb_string_free(expr_str);
+			operand->mode = Addressing_Invalid;
+			return false;
+		}
+
+		bool src_is_ptr = is_type_pointer(operand->type);
+		bool dst_is_ptr = is_type_pointer(type);
+		Type *src = type_deref(operand->type);
+		Type *dst = type_deref(type);
+		Type *bsrc = base_type(src);
+		Type *bdst = base_type(dst);
+
+		if (src_is_ptr != dst_is_ptr) {
+			gbString src_type_str = type_to_string(operand->type);
+			gbString dst_type_str = type_to_string(type);
+			error_node(operand->expr, "Invalid `union_cast` types: `%s` and `%s`", src_type_str, dst_type_str);
+			gb_string_free(dst_type_str);
+			gb_string_free(src_type_str);
+			operand->mode = Addressing_Invalid;
+			return false;
+		}
+
+		if (!is_type_union(src)) {
+			error_node(operand->expr, "`union_cast` can only operate on unions");
+			operand->mode = Addressing_Invalid;
+			return false;
+		}
+
+		bool ok = false;
+		for (isize i = 1; i < bsrc->Record.field_count; i++) {
+			Entity *f = bsrc->Record.fields[i];
+			if (are_types_identical(f->type, dst)) {
+				ok = true;
+				break;
+			}
+		}
+
+		if (!ok) {
+			gbString expr_str = expr_to_string(operand->expr);
+			gbString dst_type_str = type_to_string(type);
+			error_node(operand->expr, "Cannot `union_cast` `%s` to `%s`", expr_str, dst_type_str);
+			gb_string_free(dst_type_str);
+			gb_string_free(expr_str);
+			operand->mode = Addressing_Invalid;
+			return false;
+		}
+
+		Entity **variables = gb_alloc_array(c->allocator, Entity *, 2);
+		variables[0] = make_entity_param(c->allocator, NULL, empty_token, type, false);
+		variables[1] = make_entity_param(c->allocator, NULL, empty_token, t_bool, false);
+
+		Type *tuple = make_type_tuple(c->allocator);
+		tuple->Tuple.variables = variables;
+		tuple->Tuple.variable_count = 2;
+
+		operand->type = tuple;
+		operand->mode = Addressing_Value;
+	} break;
+	case BuiltinProc_down_cast: {
+		Type *type = check_type(c, ce->args.e[0]);
+		check_expr(c, operand, ce->args.e[1]);
+		if (operand->mode == Addressing_Invalid) {
+			return false;
+		}
+
+		if (operand->mode == Addressing_Constant) {
+			gbString expr_str = expr_to_string(operand->expr);
+			error_node(operand->expr, "Cannot `down_cast` a constant expression: `%s`", expr_str);
+			gb_string_free(expr_str);
+			operand->mode = Addressing_Invalid;
+			return false;
+		}
+
+		if (is_type_untyped(operand->type)) {
+			gbString expr_str = expr_to_string(operand->expr);
+			error_node(operand->expr, "Cannot `down_cast` an untyped expression: `%s`", expr_str);
+			gb_string_free(expr_str);
+			operand->mode = Addressing_Invalid;
+			return false;
+		}
+
+		if (!(is_type_pointer(operand->type) && is_type_pointer(type))) {
+			gbString expr_str = expr_to_string(operand->expr);
+			error_node(operand->expr, "Can only `down_cast` pointers: `%s`", expr_str);
+			gb_string_free(expr_str);
+			operand->mode = Addressing_Invalid;
+			return false;
+		}
+
+		Type *src = type_deref(operand->type);
+		Type *dst = type_deref(type);
+		Type *bsrc = base_type(src);
+		Type *bdst = base_type(dst);
+
+		if (!(is_type_struct(bsrc) || is_type_raw_union(bsrc))) {
+			gbString expr_str = expr_to_string(operand->expr);
+			error_node(operand->expr, "Can only `down_cast` pointer from structs or unions: `%s`", expr_str);
+			gb_string_free(expr_str);
+			operand->mode = Addressing_Invalid;
+			return false;
+		}
+
+		if (!(is_type_struct(bdst) || is_type_raw_union(bdst))) {
+			gbString expr_str = expr_to_string(operand->expr);
+			error_node(operand->expr, "Can only `down_cast` pointer to structs or unions: `%s`", expr_str);
+			gb_string_free(expr_str);
+			operand->mode = Addressing_Invalid;
+			return false;
+		}
+
+		String param_name = check_down_cast_name(dst, src);
+		if (param_name.len == 0) {
+			gbString expr_str = expr_to_string(operand->expr);
+			error_node(operand->expr, "Illegal `down_cast`: `%s`", expr_str);
+			gb_string_free(expr_str);
+			operand->mode = Addressing_Invalid;
+			return false;
+		}
+
+		operand->mode = Addressing_Value;
+		operand->type = type;
+	} break;
+
 
 	case BuiltinProc_compile_assert:
 		// compile_assert :: proc(cond: bool)
@@ -3054,45 +3241,6 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
 		operand->mode = Addressing_Value;
 	} break;
 
-	#if 0
-	case BuiltinProc_append: {
-		// append :: proc(x : ^[]Type, y : Type) -> bool
-		Type *x_type = NULL, *y_type = NULL;
-		x_type = base_type(operand->type);
-
-		Operand op = {0};
-		check_expr(c, &op, ce->args.e[1]);
-		if (op.mode == Addressing_Invalid) {
-			return false;
-		}
-		y_type = base_type(op.type);
-
-		if (!(is_type_pointer(x_type) && is_type_slice(x_type->Pointer.elem))) {
-			error_node(call, "First argument to `append` must be a pointer to a slice");
-			return false;
-		}
-
-		Type *elem_type = x_type->Pointer.elem->Slice.elem;
-		if (!check_is_assignable_to(c, &op, elem_type)) {
-			gbString d_arg = expr_to_string(ce->args.e[0]);
-			gbString s_arg = expr_to_string(ce->args.e[1]);
-			gbString d_str = type_to_string(elem_type);
-			gbString s_str = type_to_string(y_type);
-			error_node(call,
-			      "Arguments to `append`, %s, %s, have different element types: %s vs %s",
-			      d_arg, s_arg, d_str, s_str);
-			gb_string_free(s_str);
-			gb_string_free(d_str);
-			gb_string_free(s_arg);
-			gb_string_free(d_arg);
-			return false;
-		}
-
-		operand->type = t_bool; // Returns if it was successful
-		operand->mode = Addressing_Value;
-	} break;
-	#endif
-
 	case BuiltinProc_swizzle: {
 		// swizzle :: proc(v: {N}T, T...) -> {M}T
 		Type *vector_type = base_type(operand->type);
@@ -4557,7 +4705,7 @@ ExprKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *type_hint
 
 
 	case_ast_node(ue, UnaryExpr, node);
-		check_expr(c, o, ue->expr);
+		check_expr_base(c, o, ue->expr, type_hint);
 		if (o->mode == Addressing_Invalid) {
 			goto error;
 		}

src/checker.c

@@ -135,6 +135,10 @@ typedef enum BuiltinProcId {
 	BuiltinProc_type_info,
 	BuiltinProc_type_info_of_val,
 
+	BuiltinProc_transmute,
+	BuiltinProc_union_cast,
+	BuiltinProc_down_cast,
+
 	BuiltinProc_compile_assert,
 	BuiltinProc_assert,
 	BuiltinProc_panic,
@@ -178,6 +182,10 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_Count] = {
 	{STR_LIT("type_info"),        1, false, Expr_Expr},
 	{STR_LIT("type_info_of_val"), 1, false, Expr_Expr},
 
+	{STR_LIT("transmute"),        2, false, Expr_Expr},
+	{STR_LIT("union_cast"),       2, false, Expr_Expr},
+	{STR_LIT("down_cast"),        2, false, Expr_Expr},
+
 	{STR_LIT("compile_assert"),   1, false, Expr_Stmt},
 	{STR_LIT("assert"),           1, false, Expr_Stmt},
 	{STR_LIT("panic"),            1, false, Expr_Stmt},

src/ir.c

@@ -2772,21 +2772,21 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv
 		case Token_CmpOr:
 			return ir_emit_logical_binary_expr(proc, expr);
 
-		case Token_as:
-			ir_emit_comment(proc, str_lit("cast - as"));
-			return ir_emit_conv(proc, left, type);
+		// case Token_as:
+		// 	ir_emit_comment(proc, str_lit("cast - as"));
+		// 	return ir_emit_conv(proc, left, type);
 
-		case Token_transmute:
-			ir_emit_comment(proc, str_lit("cast - transmute"));
-			return ir_emit_transmute(proc, left, type);
+		// case Token_transmute:
+		// 	ir_emit_comment(proc, str_lit("cast - transmute"));
+		// 	return ir_emit_transmute(proc, left, type);
 
-		case Token_down_cast:
-			ir_emit_comment(proc, str_lit("cast - down_cast"));
-			return ir_emit_down_cast(proc, left, type);
+		// case Token_down_cast:
+		// 	ir_emit_comment(proc, str_lit("cast - down_cast"));
+		// 	return ir_emit_down_cast(proc, left, type);
 
-		case Token_union_cast:
-			ir_emit_comment(proc, str_lit("cast - union_cast"));
-			return ir_emit_union_cast(proc, left, type);
+		// case Token_union_cast:
+		// 	ir_emit_comment(proc, str_lit("cast - union_cast"));
+		// 	return ir_emit_union_cast(proc, left, type);
 
 		default:
 			GB_PANIC("Invalid binary expression");
@@ -2844,6 +2844,24 @@ irValue *ir_build_single_expr(irProcedure *proc, AstNode *expr, TypeAndValue *tv
 					return ir_type_info(proc, t);
 				} break;
 
+				case BuiltinProc_transmute: {
+					irValue *val = ir_build_expr(proc, ce->args.e[1]);
+					ir_emit_comment(proc, str_lit("cast - transmute"));
+					return ir_emit_transmute(proc, val, type_of_expr(proc->module->info, ce->args.e[0]));
+				}
+
+				case BuiltinProc_down_cast: {
+					irValue *val = ir_build_expr(proc, ce->args.e[1]);
+					ir_emit_comment(proc, str_lit("cast - down_cast"));
+					return ir_emit_down_cast(proc, val, type_of_expr(proc->module->info, ce->args.e[0]));
+				}
+
+				case BuiltinProc_union_cast: {
+					irValue *val = ir_build_expr(proc, ce->args.e[1]);
+					ir_emit_comment(proc, str_lit("cast - union_cast"));
+					return ir_emit_union_cast(proc, val, type_of_expr(proc->module->info, ce->args.e[0]));
+				}
+
 				case BuiltinProc_new: {
 					ir_emit_comment(proc, str_lit("new"));
 					// new :: proc(Type) -> ^Type
@@ -3399,22 +3417,22 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) {
 
 	case_ast_node(be, BinaryExpr, expr);
 		switch (be->op.kind) {
-		case Token_as: {
-			ir_emit_comment(proc, str_lit("Cast - as"));
-			// NOTE(bill): Needed for dereference of pointer conversion
-			Type *type = type_of_expr(proc->module->info, expr);
-			irValue *v = ir_add_local_generated(proc, type);
-			ir_emit_store(proc, v, ir_emit_conv(proc, ir_build_expr(proc, be->left), type));
-			return ir_make_addr(v, expr);
-		}
-		case Token_transmute: {
-			ir_emit_comment(proc, str_lit("Cast - transmute"));
-			// NOTE(bill): Needed for dereference of pointer conversion
-			Type *type = type_of_expr(proc->module->info, expr);
-			irValue *v = ir_add_local_generated(proc, type);
-			ir_emit_store(proc, v, ir_emit_transmute(proc, ir_build_expr(proc, be->left), type));
-			return ir_make_addr(v, expr);
-		}
+		// case Token_as: {
+		// 	ir_emit_comment(proc, str_lit("Cast - as"));
+		// 	// NOTE(bill): Needed for dereference of pointer conversion
+		// 	Type *type = type_of_expr(proc->module->info, expr);
+		// 	irValue *v = ir_add_local_generated(proc, type);
+		// 	ir_emit_store(proc, v, ir_emit_conv(proc, ir_build_expr(proc, be->left), type));
+		// 	return ir_make_addr(v, expr);
+		// }
+		// case Token_transmute: {
+		// 	ir_emit_comment(proc, str_lit("Cast - transmute"));
+		// 	// NOTE(bill): Needed for dereference of pointer conversion
+		// 	Type *type = type_of_expr(proc->module->info, expr);
+		// 	irValue *v = ir_add_local_generated(proc, type);
+		// 	ir_emit_store(proc, v, ir_emit_transmute(proc, ir_build_expr(proc, be->left), type));
+		// 	return ir_make_addr(v, expr);
+		// }
 		default:
 			GB_PANIC("Invalid binary expression for ir_build_addr: %.*s\n", LIT(be->op.string));
 			break;

src/parser.c

@@ -1979,11 +1979,11 @@ i32 token_precedence(Token t) {
 	case Token_Shl:
 	case Token_Shr:
 		return 5;
-	case Token_as:
-	case Token_transmute:
-	case Token_down_cast:
-	case Token_union_cast:
-		return 6;
+	// case Token_as:
+	// case Token_transmute:
+	// case Token_down_cast:
+	// case Token_union_cast:
+		// return 6;
 	}
 	return 0;
 }
@@ -2005,12 +2005,12 @@ AstNode *parse_binary_expr(AstFile *f, bool lhs, i32 prec_in) {
 			}
 
 			switch (op.kind) {
-			case Token_as:
+			/* case Token_as:
 			case Token_transmute:
 			case Token_down_cast:
 			case Token_union_cast:
 				right = parse_type(f);
-				break;
+				break; */
 
 			default:
 				right = parse_binary_expr(f, false, prec+1);
@@ -2429,10 +2429,10 @@ AstNode *parse_identifier_or_type(AstFile *f) {
 			AstNode *sel = parse_identifier(f);
 			e = make_selector_expr(f, token, e, sel);
 		}
-		if (f->curr_token.kind == Token_OpenParen) {
-			// HACK NOTE(bill): For type_of_val(expr)
-			e = parse_call_expr(f, e);
-		}
+		// if (f->curr_token.kind == Token_OpenParen) {
+		// 	// HACK NOTE(bill): For type_of_val(expr)
+		// 	e = parse_call_expr(f, e);
+		// }
 		return e;
 	}
 
@@ -2560,11 +2560,9 @@ AstNode *parse_identifier_or_type(AstFile *f) {
 
 	case Token_OpenParen: {
 		// NOTE(bill): Skip the paren expression
-		AstNode *type;
-		Token open, close;
-		open = expect_token(f, Token_OpenParen);
-		type = parse_type(f);
-		close = expect_token(f, Token_CloseParen);
+		Token    open  = expect_token(f, Token_OpenParen);
+		AstNode *type  = parse_type(f);
+		Token    close = expect_token(f, Token_CloseParen);
 		return type;
 		// return make_paren_expr(f, type, open, close);
 	} break;

src/string.c

@@ -46,7 +46,7 @@ gb_inline String make_string_c(char *text) {
 	return make_string(cast(u8 *)cast(void *)text, gb_strlen(text));
 }
 
-#define str_lit(c_str) make_string(cast(u8 *)c_str, gb_size_of(c_str)-1)
+#define str_lit(c_str) (String){cast(u8 *)c_str, gb_size_of(c_str)-1}
 
 
 

src/tokenizer.c

@@ -1,82 +1,82 @@
 #define TOKEN_KINDS \
 	TOKEN_KIND(Token_Invalid, "Invalid"), \
-	TOKEN_KIND(Token_EOF, "EOF"), \
+	TOKEN_KIND(Token_EOF,     "EOF"), \
 	TOKEN_KIND(Token_Comment, "Comment"), \
 \
 TOKEN_KIND(Token__LiteralBegin, "_LiteralBegin"), \
-	TOKEN_KIND(Token_Ident, "identifier"), \
-	TOKEN_KIND(Token_Integer, "integer"), \
-	TOKEN_KIND(Token_Float, "float"), \
-	TOKEN_KIND(Token_Rune, "rune"), \
-	TOKEN_KIND(Token_String, "string"), \
-TOKEN_KIND(Token__LiteralEnd, "_LiteralEnd"), \
+	TOKEN_KIND(Token_Ident,     "identifier"), \
+	TOKEN_KIND(Token_Integer,   "integer"), \
+	TOKEN_KIND(Token_Float,     "float"), \
+	TOKEN_KIND(Token_Rune,      "rune"), \
+	TOKEN_KIND(Token_String,    "string"), \
+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_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_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_as,         "as"), \
-	TOKEN_KIND(Token_transmute,  "transmute"), \
-	TOKEN_KIND(Token_down_cast,  "down_cast"), \
-	TOKEN_KIND(Token_union_cast, "union_cast"), \
+	/*TOKEN_KIND(Token_as,         "as"), */\
+	/*TOKEN_KIND(Token_transmute,  "transmute"), */\
+	/*TOKEN_KIND(Token_down_cast,  "down_cast"), */\
+	/*TOKEN_KIND(Token_union_cast, "union_cast"), */\
 \
 	TOKEN_KIND(Token_CmpAnd, "&&"), \
-	TOKEN_KIND(Token_CmpOr, "||"), \
+	TOKEN_KIND(Token_CmpOr,  "||"), \
 \
 TOKEN_KIND(Token__AssignOpBegin, "_AssignOpBegin"), \
-	TOKEN_KIND(Token_AddEq, "+="), \
-	TOKEN_KIND(Token_SubEq, "-="), \
-	TOKEN_KIND(Token_MulEq, "*="), \
-	TOKEN_KIND(Token_QuoEq, "/="), \
-	TOKEN_KIND(Token_ModEq, "%="), \
-	TOKEN_KIND(Token_AndEq, "&="), \
-	TOKEN_KIND(Token_OrEq, "|="), \
-	TOKEN_KIND(Token_XorEq, "~="), \
-	TOKEN_KIND(Token_AndNotEq, "&~="), \
-	TOKEN_KIND(Token_ShlEq, "<<="), \
-	TOKEN_KIND(Token_ShrEq, ">>="), \
-	TOKEN_KIND(Token_CmpAndEq, "&&="), \
-	TOKEN_KIND(Token_CmpOrEq, "||="), \
-TOKEN_KIND(Token__AssignOpEnd, "_AssignOpEnd"), \
+	TOKEN_KIND(Token_AddEq,      "+="), \
+	TOKEN_KIND(Token_SubEq,      "-="), \
+	TOKEN_KIND(Token_MulEq,      "*="), \
+	TOKEN_KIND(Token_QuoEq,      "/="), \
+	TOKEN_KIND(Token_ModEq,      "%="), \
+	TOKEN_KIND(Token_AndEq,      "&="), \
+	TOKEN_KIND(Token_OrEq,       "|="), \
+	TOKEN_KIND(Token_XorEq,      "~="), \
+	TOKEN_KIND(Token_AndNotEq,   "&~="), \
+	TOKEN_KIND(Token_ShlEq,      "<<="), \
+	TOKEN_KIND(Token_ShrEq,      ">>="), \
+	TOKEN_KIND(Token_CmpAndEq,   "&&="), \
+	TOKEN_KIND(Token_CmpOrEq,    "||="), \
+TOKEN_KIND(Token__AssignOpEnd,   "_AssignOpEnd"), \
 	TOKEN_KIND(Token_ArrowRight, "->"), \
-	TOKEN_KIND(Token_ArrowLeft, "<-"), \
+	TOKEN_KIND(Token_ArrowLeft,  "<-"), \
 \
 TOKEN_KIND(Token__ComparisonBegin, "_ComparisonBegin"), \
 	TOKEN_KIND(Token_CmpEq, "=="), \
 	TOKEN_KIND(Token_NotEq, "!="), \
-	TOKEN_KIND(Token_Lt, "<"), \
-	TOKEN_KIND(Token_Gt, ">"), \
-	TOKEN_KIND(Token_LtEq, "<="), \
-	TOKEN_KIND(Token_GtEq, ">="), \
+	TOKEN_KIND(Token_Lt,    "<"), \
+	TOKEN_KIND(Token_Gt,    ">"), \
+	TOKEN_KIND(Token_LtEq,  "<="), \
+	TOKEN_KIND(Token_GtEq,  ">="), \
 TOKEN_KIND(Token__ComparisonEnd, "_ComparisonEnd"), \
 \
-	TOKEN_KIND(Token_OpenParen, "("), \
-	TOKEN_KIND(Token_CloseParen, ")"), \
-	TOKEN_KIND(Token_OpenBracket, "["), \
+	TOKEN_KIND(Token_OpenParen,    "("), \
+	TOKEN_KIND(Token_CloseParen,   ")"), \
+	TOKEN_KIND(Token_OpenBracket,  "["), \
 	TOKEN_KIND(Token_CloseBracket, "]"), \
-	TOKEN_KIND(Token_OpenBrace, "{"), \
-	TOKEN_KIND(Token_CloseBrace, "}"), \
-	TOKEN_KIND(Token_Colon, ":"), \
-	TOKEN_KIND(Token_Semicolon, ";"), \
-	TOKEN_KIND(Token_Period, "."), \
-	TOKEN_KIND(Token_Comma, ","), \
-	TOKEN_KIND(Token_Ellipsis, "..."), \
-	TOKEN_KIND(Token_Interval, "..<"), \
+	TOKEN_KIND(Token_OpenBrace,    "{"), \
+	TOKEN_KIND(Token_CloseBrace,   "}"), \
+	TOKEN_KIND(Token_Colon,        ":"), \
+	TOKEN_KIND(Token_Semicolon,    ";"), \
+	TOKEN_KIND(Token_Period,       "."), \
+	TOKEN_KIND(Token_Comma,        ","), \
+	TOKEN_KIND(Token_Ellipsis,     "..."), \
+	TOKEN_KIND(Token_Interval,     "..<"), \
 TOKEN_KIND(Token__OperatorEnd, "_OperatorEnd"), \
 \
 TOKEN_KIND(Token__KeywordBegin, "_KeywordBegin"), \
@@ -722,7 +722,7 @@ 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])) {
+			/* 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;
@@ -730,7 +730,7 @@ Token tokenizer_get_token(Tokenizer *t) {
 				token.kind = Token_down_cast;
 			} else if (str_eq(token.string, token_strings[Token_union_cast])) {
 				token.kind = Token_union_cast;
-			} else {
+			} else  */{
 				for (i32 k = Token__KeywordBegin+1; k < Token__KeywordEnd; k++) {
 					if (str_eq(token.string, token_strings[k])) {
 						token.kind = cast(TokenKind)k;