Remove `atomic`, `++`, and `--`

9 files changed, 35 insertions, 106 deletions

diff --git a/src/check_expr.cpp b/src/check_expr.cpp
index 15bdf2751..cdbeba913 100644
--- a/src/check_expr.cpp
+++ b/src/check_expr.cpp
@@ -1711,11 +1711,6 @@ bool is_polymorphic_type_assignable(Checker *c, Type *poly, Type *source, bool c
 			return is_polymorphic_type_assignable(c, poly->Pointer.elem, source->Pointer.elem, true, modify_type);
 		}
 		return false;
-	case Type_Atomic:
-		if (source->kind == Type_Atomic) {
-			return is_polymorphic_type_assignable(c, poly->Atomic.elem, source->Atomic.elem, true, modify_type);
-		}
-		return false;
 	case Type_Array:
 		if (source->kind == Type_Array &&
 		    poly->Array.count == source->Array.count) {
@@ -2942,13 +2937,6 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type)
 		return true;
 	case_end;
 
-	case_ast_node(at, AtomicType, e);
-		Type *elem = check_type(c, at->type);
-		i64 esz = type_size_of(c->allocator, elem);
-		*type = make_type_atomic(c->allocator, elem);
-		return true;
-	case_end;
-
 	case_ast_node(at, ArrayType, e);
 		if (at->count != nullptr) {
 			Type *elem = check_type(c, at->elem, nullptr);
@@ -8399,11 +8387,6 @@ gbString write_expr_to_string(gbString str, AstNode *node) {
 		}
 		str = gb_string_appendc(str, "}");
 	case_end;
-
-	case_ast_node(at, AtomicType, node);
-		str = gb_string_appendc(str, "atomic ");
-		str = write_expr_to_string(str, at->type);
-	case_end;
 	}
 
 	return str;
diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp
index 5df8694b1..751e9759e 100644
--- a/src/check_stmt.cpp
+++ b/src/check_stmt.cpp
@@ -629,6 +629,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
 		check_stmt(c, ts->stmt, flags);
 	case_end;
 
+	#if 0
 	case_ast_node(s, IncDecStmt, node);
 		TokenKind op = s->op.kind;
 		switch (op) {
@@ -671,6 +672,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
 		}
 		check_assignment_variable(c, &x, left);
 	case_end;
+	#endif
 
 	case_ast_node(as, AssignStmt, node);
 		switch (as->op.kind) {
diff --git a/src/checker.cpp b/src/checker.cpp
index cdc9bf3b4..1d566ef4b 100644
--- a/src/checker.cpp
+++ b/src/checker.cpp
@@ -1142,10 +1142,6 @@ void add_type_info_type(Checker *c, Type *t) {
 		add_type_info_type(c, bt->Pointer.elem);
 		break;
 
-	case Type_Atomic:
-		add_type_info_type(c, bt->Atomic.elem);
-		break;
-
 	case Type_Array:
 		add_type_info_type(c, bt->Array.elem);
 		add_type_info_type(c, make_type_pointer(c->allocator, bt->Array.elem));
@@ -1361,7 +1357,7 @@ void init_preload(Checker *c) {
 		GB_ASSERT(is_type_union(tiv_type));
 		TypeUnion *tiv = &tiv_type->Union;
 
-		if (tiv->variant_count != 23) {
+		if (tiv->variant_count != 22) {
 			compiler_error("Invalid `TypeInfo` layout");
 		}
 		t_type_info_named         = tiv->variants[ 1];
@@ -1373,19 +1369,18 @@ void init_preload(Checker *c) {
 		t_type_info_boolean       = tiv->variants[ 7];
 		t_type_info_any           = tiv->variants[ 8];
 		t_type_info_pointer       = tiv->variants[ 9];
-		t_type_info_atomic        = tiv->variants[10];
-		t_type_info_procedure     = tiv->variants[11];
-		t_type_info_array         = tiv->variants[12];
-		t_type_info_dynamic_array = tiv->variants[13];
-		t_type_info_slice         = tiv->variants[14];
-		t_type_info_vector        = tiv->variants[15];
-		t_type_info_tuple         = tiv->variants[16];
-		t_type_info_struct        = tiv->variants[17];
-		t_type_info_raw_union     = tiv->variants[18];
-		t_type_info_union         = tiv->variants[19];
-		t_type_info_enum          = tiv->variants[20];
-		t_type_info_map           = tiv->variants[21];
-		t_type_info_bit_field     = tiv->variants[22];
+		t_type_info_procedure     = tiv->variants[10];
+		t_type_info_array         = tiv->variants[11];
+		t_type_info_dynamic_array = tiv->variants[12];
+		t_type_info_slice         = tiv->variants[13];
+		t_type_info_vector        = tiv->variants[14];
+		t_type_info_tuple         = tiv->variants[15];
+		t_type_info_struct        = tiv->variants[16];
+		t_type_info_raw_union     = tiv->variants[17];
+		t_type_info_union         = tiv->variants[18];
+		t_type_info_enum          = tiv->variants[19];
+		t_type_info_map           = tiv->variants[20];
+		t_type_info_bit_field     = tiv->variants[21];
 
 		t_type_info_named_ptr         = make_type_pointer(c->allocator, t_type_info_named);
 		t_type_info_integer_ptr       = make_type_pointer(c->allocator, t_type_info_integer);
@@ -1396,7 +1391,6 @@ void init_preload(Checker *c) {
 		t_type_info_boolean_ptr       = make_type_pointer(c->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(c->allocator, t_type_info_pointer);
-		t_type_info_atomic_ptr        = make_type_pointer(c->allocator, t_type_info_atomic);
 		t_type_info_procedure_ptr     = make_type_pointer(c->allocator, t_type_info_procedure);
 		t_type_info_array_ptr         = make_type_pointer(c->allocator, t_type_info_array);
 		t_type_info_dynamic_array_ptr = make_type_pointer(c->allocator, t_type_info_dynamic_array);
diff --git a/src/ir.cpp b/src/ir.cpp
index c525419af..d49b53c7c 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -151,7 +151,7 @@ struct irProcedure {
 		Entity *     entity;                                          \
 		Type *       type;                                            \
 		bool         zero_initialized;                                \
-		Array<irValue *> referrers;                                       \
+		Array<irValue *> referrers;                                   \
 		i64          alignment;                                       \
 	})                                                                \
 	IR_INSTR_KIND(ZeroInit, struct { irValue *address; })             \
@@ -1481,7 +1481,7 @@ irValue *ir_emit_store(irProcedure *p, irValue *address, irValue *value) {
 		GB_ASSERT_MSG(are_types_identical(core_type(a), core_type(b)), "%s %s", type_to_string(a), type_to_string(b));
 	}
 #endif
-	return ir_emit(p, ir_instr_store(p, address, value, is_type_atomic(a)));
+	return ir_emit(p, ir_instr_store(p, address, value, false));
 }
 irValue *ir_emit_load(irProcedure *p, irValue *address) {
 	GB_ASSERT(address != nullptr);
@@ -6233,6 +6233,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) {
 		ir_build_when_stmt(proc, ws);
 	case_end;
 
+	#if 0
 	case_ast_node(s, IncDecStmt, node);
 		TokenKind op = Token_Add;
 		if (s->op.kind == Token_Dec) {
@@ -6241,6 +6242,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) {
 		irAddr addr = ir_build_addr(proc, s->expr);
 		ir_build_assign_op(proc, addr, v_one, op);
 	case_end;
+	#endif
 
 	case_ast_node(vd, ValueDecl, node);
 		if (vd->is_mutable) {
@@ -8024,12 +8026,6 @@ void ir_gen_tree(irGen *s) {
 					irValue *gep = ir_get_type_info_ptr(proc, t->Pointer.elem);
 					ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
 				} break;
-				case Type_Atomic: {
-					ir_emit_comment(proc, str_lit("TypeInfoAtomic"));
-					tag = ir_emit_conv(proc, variant_ptr, t_type_info_atomic_ptr);
-					irValue *gep = ir_get_type_info_ptr(proc, t->Atomic.elem);
-					ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
-				} break;
 				case Type_Array: {
 					ir_emit_comment(proc, str_lit("TypeInfoArray"));
 					tag = ir_emit_conv(proc, variant_ptr, t_type_info_array_ptr);
diff --git a/src/ir_print.cpp b/src/ir_print.cpp
index cb7ee0185..e2b4fcb1a 100644
--- a/src/ir_print.cpp
+++ b/src/ir_print.cpp
@@ -252,9 +252,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_Atomic:
-		ir_print_type(f, m, t->Atomic.elem);
-		return;
 	case Type_Array:
 		ir_fprintf(f, "[%lld x ", t->Array.count);
 		ir_print_type(f, m, t->Array.elem);
@@ -890,7 +887,7 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) {
 		ir_print_type(f, m, type);
 		ir_fprintf(f, "* ");
 		ir_print_value(f, m, instr->Store.address, type);
-		if (is_type_atomic(type)) {
+		if (instr->Store.atomic) {
 			// TODO(bill): Do ordering
 			ir_fprintf(f, " unordered");
 			ir_fprintf(f, ", align %lld\n", type_align_of(m->allocator, type));
@@ -901,18 +898,18 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) {
 	case irInstr_Load: {
 		Type *type = instr->Load.type;
 		ir_fprintf(f, "%%%d = load ", value->index);
-		if (is_type_atomic(type)) {
-			ir_fprintf(f, "atomic ");
-		}
+		// if (is_type_atomic(type)) {
+			// ir_fprintf(f, "atomic ");
+		// }
 		ir_print_type(f, m, type);
 		ir_fprintf(f, ", ");
 		ir_print_type(f, m, type);
 		ir_fprintf(f, "* ");
 		ir_print_value(f, m, instr->Load.address, type);
-		if (is_type_atomic(type)) {
+		// if (is_type_atomic(type)) {
 			// TODO(bill): Do ordering
-			ir_fprintf(f, " unordered");
-		}
+			// ir_fprintf(f, " unordered");
+		// }
 		ir_fprintf(f, ", align %lld\n", type_align_of(m->allocator, type));
 	} break;
 
diff --git a/src/parser.cpp b/src/parser.cpp
index 1b95b0cc1..cd47bd173 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -402,10 +402,6 @@ AST_NODE_KIND(_TypeBegin, "", i32) \
 		Token token; \
 		AstNode *type; \
 	}) \
-	AST_NODE_KIND(AtomicType, "atomic type", struct { \
-		Token token; \
-		AstNode *type; \
-	}) \
 	AST_NODE_KIND(ArrayType, "array type", struct { \
 		Token token; \
 		AstNode *count; \
@@ -598,7 +594,6 @@ Token ast_node_token(AstNode *node) {
 	case AstNode_PolyType:         return node->PolyType.token;
 	case AstNode_ProcType:         return node->ProcType.token;
 	case AstNode_PointerType:      return node->PointerType.token;
-	case AstNode_AtomicType:       return node->AtomicType.token;
 	case AstNode_ArrayType:        return node->ArrayType.token;
 	case AstNode_DynamicArrayType: return node->DynamicArrayType.token;
 	case AstNode_VectorType:       return node->VectorType.token;
@@ -854,9 +849,6 @@ AstNode *clone_ast_node(gbAllocator a, AstNode *node) {
 	case AstNode_PointerType:
 		n->PointerType.type = clone_ast_node(a, n->PointerType.type);
 		break;
-	case AstNode_AtomicType:
-		n->AtomicType.type = clone_ast_node(a, n->AtomicType.type);
-		break;
 	case AstNode_ArrayType:
 		n->ArrayType.count = clone_ast_node(a, n->ArrayType.count);
 		n->ArrayType.elem  = clone_ast_node(a, n->ArrayType.elem);
@@ -1435,13 +1427,6 @@ AstNode *ast_pointer_type(AstFile *f, Token token, AstNode *type) {
 	return result;
 }
 
-AstNode *ast_atomic_type(AstFile *f, Token token, AstNode *type) {
-	AstNode *result = make_ast_node(f, AstNode_AtomicType);
-	result->AtomicType.token = token;
-	result->AtomicType.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;
@@ -1850,9 +1835,6 @@ bool is_semicolon_optional_for_node(AstFile *f, AstNode *s) {
 	case AstNode_PointerType:
 		return is_semicolon_optional_for_node(f, s->PointerType.type);
 
-	case AstNode_AtomicType:
-		return is_semicolon_optional_for_node(f, s->AtomicType.type);
-
 	case AstNode_StructType:
 	case AstNode_UnionType:
 	case AstNode_RawUnionType:
@@ -2390,12 +2372,6 @@ AstNode *parse_operand(AstFile *f, bool lhs) {
 		return ast_pointer_type(f, token, elem);
 	} break;
 
-	case Token_atomic: {
-		Token token = expect_token(f, Token_atomic);
-		AstNode *elem = parse_type(f);
-		return ast_atomic_type(f, token, elem);
-	} break;
-
 	case Token_OpenBracket: {
 		Token token = expect_token(f, Token_OpenBracket);
 		AstNode *count_expr = nullptr;
@@ -3402,12 +3378,14 @@ AstNode *parse_simple_stmt(AstFile *f, StmtAllowFlag flags) {
 
 
 
+	#if 0
 	switch (token.kind) {
 	case Token_Inc:
 	case Token_Dec:
 		advance_token(f);
 		return ast_inc_dec_stmt(f, token, lhs[0]);
 	}
+	#endif
 
 	return ast_expr_stmt(f, lhs[0]);
 }
diff --git a/src/ssa.cpp b/src/ssa.cpp
index 248999e39..03810e354 100644
--- a/src/ssa.cpp
+++ b/src/ssa.cpp
@@ -1956,6 +1956,7 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) {
 		ssa_build_when_stmt(p, ws);
 	case_end;
 
+	#if 0
 	case_ast_node(s, IncDecStmt, node);
 		TokenKind op = Token_Add;
 		if (s->op.kind == Token_Dec) {
@@ -1965,6 +1966,7 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) {
 		Type *t = ssa_addr_type(addr);
 		ssa_build_assign_op(p, addr, ssa_const_int(p, t, 1), op);
 	case_end;
+	#endif
 
 	case_ast_node(as, AssignStmt, node);
 		ssa_emit_comment(p, str_lit("AssignStmt"));
diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp
index 4c66f17a2..53e71a3c3 100644
--- a/src/tokenizer.cpp
+++ b/src/tokenizer.cpp
@@ -55,8 +55,8 @@ TOKEN_KIND(Token__AssignOpEnd, "_AssignOpEnd"), \
 	TOKEN_KIND(Token_ArrowRight,       "->"), \
 	TOKEN_KIND(Token_ArrowLeft,        "<-"), \
 	TOKEN_KIND(Token_DoubleArrowRight, "=>"), \
-	TOKEN_KIND(Token_Inc,              "++"), \
-	TOKEN_KIND(Token_Dec,              "--"), \
+/* 	TOKEN_KIND(Token_Inc,              "++"), */ \
+/* 	TOKEN_KIND(Token_Dec,              "--"), */ \
 	TOKEN_KIND(Token_Undef,            "---"), \
 \
 TOKEN_KIND(Token__ComparisonBegin, "_ComparisonBegin"), \
@@ -126,7 +126,6 @@ TOKEN_KIND(Token__KeywordBegin, "_KeywordBegin"), \
 	TOKEN_KIND(Token_asm,                    "asm"),                    \
 	TOKEN_KIND(Token_yield,                  "yield"),                  \
 	TOKEN_KIND(Token_await,                  "await"),                  \
-	TOKEN_KIND(Token_atomic,                 "atomic"),                 \
 TOKEN_KIND(Token__KeywordEnd, "_KeywordEnd"), \
 	TOKEN_KIND(Token_Count, "")
 
@@ -929,7 +928,8 @@ Token tokenizer_get_token(Tokenizer *t) {
 			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_Inc);                        break;
+		// case '+': token.kind = token_kind_variant3(t, Token_Add, Token_AddEq, '+', Token_Inc);                        break;
+		case '+': token.kind = token_kind_variant2(t, Token_Add, Token_AddEq);                                        break;
 		case '-':
 			token.kind = Token_Sub;
 			if (t->curr_rune == '=') {
@@ -937,7 +937,7 @@ Token tokenizer_get_token(Tokenizer *t) {
 				token.kind = Token_SubEq;
 			} else if (t->curr_rune == '-') {
 				advance_to_next_rune(t);
-				token.kind = Token_Dec;
+				token.kind = Token_Invalid;
 				if (t->curr_rune == '-') {
 					advance_to_next_rune(t);
 					token.kind = Token_Undef;
diff --git a/src/types.cpp b/src/types.cpp
index 96cec42c4..3c9d99728 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -111,7 +111,6 @@ struct TypeRecord {
 		Type * specialized;                               \
 	})                                                    \
 	TYPE_KIND(Pointer, struct { Type *elem; })            \
-	TYPE_KIND(Atomic,  struct { Type *elem; })            \
 	TYPE_KIND(Array,   struct { Type *elem; i64 count; }) \
 	TYPE_KIND(DynamicArray, struct { Type *elem; })       \
 	TYPE_KIND(Vector,  struct { Type *elem; i64 count; }) \
@@ -355,7 +354,6 @@ gb_global Type *t_type_info_any               = nullptr;
 gb_global Type *t_type_info_string            = nullptr;
 gb_global Type *t_type_info_boolean           = nullptr;
 gb_global Type *t_type_info_pointer           = nullptr;
-gb_global Type *t_type_info_atomic            = nullptr;
 gb_global Type *t_type_info_procedure         = nullptr;
 gb_global Type *t_type_info_array             = nullptr;
 gb_global Type *t_type_info_dynamic_array     = nullptr;
@@ -379,7 +377,6 @@ gb_global Type *t_type_info_any_ptr           = nullptr;
 gb_global Type *t_type_info_string_ptr        = nullptr;
 gb_global Type *t_type_info_boolean_ptr       = nullptr;
 gb_global Type *t_type_info_pointer_ptr       = nullptr;
-gb_global Type *t_type_info_atomic_ptr        = nullptr;
 gb_global Type *t_type_info_procedure_ptr     = nullptr;
 gb_global Type *t_type_info_array_ptr         = nullptr;
 gb_global Type *t_type_info_dynamic_array_ptr = nullptr;
@@ -456,9 +453,6 @@ Type *core_type(Type *t) {
 		case Type_Enum:
 			t = t->Enum.base_type;
 			continue;
-		case Type_Atomic:
-			t = t->Atomic.elem;
-			continue;
 		}
 		break;
 	}
@@ -500,12 +494,6 @@ Type *make_type_pointer(gbAllocator a, Type *elem) {
 	return t;
 }
 
-Type *make_type_atomic(gbAllocator a, Type *elem) {
-	Type *t = alloc_type(a, Type_Atomic);
-	t->Atomic.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;
@@ -774,10 +762,6 @@ bool is_type_pointer(Type *t) {
 	}
 	return t->kind == Type_Pointer;
 }
-bool is_type_atomic(Type *t) {
-	t = base_type(t);
-	return t->kind == Type_Atomic;
-}
 bool is_type_tuple(Type *t) {
 	t = base_type(t);
 	return t->kind == Type_Tuple;
@@ -975,8 +959,6 @@ bool is_type_polymorphic(Type *t) {
 
 	case Type_Pointer:
 		return is_type_polymorphic(t->Pointer.elem);
-	case Type_Atomic:
-		return is_type_polymorphic(t->Atomic.elem);
 	case Type_Array:
 		return is_type_polymorphic(t->Array.elem);
 	case Type_DynamicArray:
@@ -2307,11 +2289,6 @@ gbString write_type_to_string(gbString str, Type *type) {
 		str = write_type_to_string(str, type->Pointer.elem);
 		break;
 
-	case Type_Atomic:
-		str = gb_string_appendc(str, "atomic ");
-		str = write_type_to_string(str, type->Atomic.elem);
-		break;
-
 	case Type_Array:
 		str = gb_string_appendc(str, gb_bprintf("[%d]", cast(int)type->Array.count));
 		str = write_type_to_string(str, type->Array.elem);