Remove `#opaque` types

core/encoding/json/marshal.odin

@@ -308,9 +308,6 @@ marshal_arg :: proc(b: ^strings.Builder, v: any) -> Marshal_Error {
 		write_u64(b, bit_data);
 
 
-		return .Unsupported_Type;
-
-	case Type_Info_Opaque:
 		return .Unsupported_Type;
 	}
 

core/fmt/fmt.odin

@@ -1247,49 +1247,6 @@ fmt_write_array :: proc(fi: ^Info, array_data: rawptr, count: int, elem_size: in
 	}
 }
 
-fmt_opaque :: proc(fi: ^Info, v: any) {
-	is_nil :: proc(data: rawptr, n: int) -> bool {
-		if data == nil { return true; }
-		if n == 0 { return true; }
-
-		a := (^byte)(data);
-		for i in 0..<n {
-			if mem.ptr_offset(a, i)^ != 0 {
-				return false;
-			}
-		}
-		return true;
-	}
-
-	rt :: runtime;
-
-	type_info := type_info_of(v.id);
-
-	if is_nil(v.data, type_info.size) {
-		io.write_string(fi.writer, "nil");
-		return;
-	}
-
-	if ot, ok := rt.type_info_base(type_info).variant.(rt.Type_Info_Opaque); ok {
-		elem := rt.type_info_base(ot.elem);
-		if elem == nil { return; }
-		reflect.write_type(fi.writer, type_info);
-		io.write_byte(fi.writer, '{');
-		defer io.write_byte(fi.writer, '}');
-
-		#partial switch in elem.variant {
-		case rt.Type_Info_Integer, rt.Type_Info_Pointer, rt.Type_Info_Float:
-			fmt_value(fi, any{v.data, elem.id}, 'v');
-		case:
-			// Okay
-		}
-	} else {
-		reflect.write_type(fi.writer, type_info);
-		io.write_byte(fi.writer, '{');
-		io.write_byte(fi.writer, '}');
-	}
-}
-
 fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 	write_padded_number :: proc(fi: ^Info, i: i64, width: int) {
 		n := width-1;
@@ -1553,8 +1510,6 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 
 		case runtime.Type_Info_Bit_Set:
 			fmt_bit_set(fi, v);
-		case runtime.Type_Info_Opaque:
-			fmt_opaque(fi, v);
 		case:
 			fmt_value(fi, any{v.data, info.base.id}, verb);
 		}
@@ -1924,9 +1879,6 @@ fmt_value :: proc(fi: ^Info, v: any, verb: rune) {
 	case runtime.Type_Info_Bit_Set:
 		fmt_bit_set(fi, v);
 
-	case runtime.Type_Info_Opaque:
-		fmt_opaque(fi, v);
-
 	case runtime.Type_Info_Relative_Pointer:
 		ptr := reflect.relative_pointer_to_absolute_raw(v.data, info.base_integer.id);
 		absolute_ptr := any{ptr, info.pointer.id};

core/intrinsics/intrinsics.odin

@@ -121,7 +121,6 @@ type_is_valid_map_key   :: proc($T: typeid) -> bool ---
 
 type_is_named            :: proc($T: typeid) -> bool ---
 type_is_pointer          :: proc($T: typeid) -> bool ---
-type_is_opaque           :: proc($T: typeid) -> bool ---
 type_is_array            :: proc($T: typeid) -> bool ---
 type_is_enumerated_array :: proc($T: typeid) -> bool ---
 type_is_slice            :: proc($T: typeid) -> bool ---

core/odin/ast/ast.odin

@@ -630,11 +630,6 @@ Distinct_Type :: struct {
 	type: ^Expr,
 }
 
-Opaque_Type :: struct {
-	using node: Expr,
-	type: ^Expr,
-}
-
 Poly_Type :: struct {
 	using node: Expr,
 	dollar:         tokenizer.Pos,

core/odin/ast/clone.odin

@@ -243,8 +243,6 @@ clone_node :: proc(node: ^Node) -> ^Node {
 		r.type = clone(r.type);
 	case Distinct_Type:
 		r.type = clone(r.type);
-	case Opaque_Type:
-		r.type = clone(r.type);
 	case Poly_Type:
 		r.type = auto_cast clone(r.type);
 		r.specialization = clone(r.specialization);

core/odin/ast/walk.odin

@@ -339,8 +339,6 @@ walk :: proc(v: ^Visitor, node: ^Node) {
 		walk(v, n.type);
 	case Distinct_Type:
 		walk(v, n.type);
-	case Opaque_Type:
-		walk(v, n.type);
 	case Poly_Type:
 		walk(v, n.type);
 		if n.specialization != nil {

core/odin/parser/parser.odin

@@ -2101,12 +2101,6 @@ parse_operand :: proc(p: ^Parser, lhs: bool) -> ^ast.Expr {
 		tok := expect_token(p, .Hash);
 		name := expect_token(p, .Ident);
 		switch name.text {
-		case "opaque":
-			type := parse_type(p);
-			ot := ast.new(ast.Opaque_Type, tok.pos, type.end);
-			ot.type = type;
-			return ot;
-
 		case "type":
 			type := parse_type(p);
 			hp := ast.new(ast.Helper_Type, tok.pos, type.end);

core/reflect/reflect.odin

@@ -29,7 +29,6 @@ Type_Info_Union            :: runtime.Type_Info_Union;
 Type_Info_Enum             :: runtime.Type_Info_Enum;
 Type_Info_Map              :: runtime.Type_Info_Map;
 Type_Info_Bit_Set          :: runtime.Type_Info_Bit_Set;
-Type_Info_Opaque           :: runtime.Type_Info_Opaque;
 Type_Info_Simd_Vector      :: runtime.Type_Info_Simd_Vector;
 Type_Info_Relative_Pointer :: runtime.Type_Info_Relative_Pointer;
 Type_Info_Relative_Slice   :: runtime.Type_Info_Relative_Slice;
@@ -60,7 +59,6 @@ Type_Kind :: enum {
 	Enum,
 	Map,
 	Bit_Set,
-	Opaque,
 	Simd_Vector,
 	Relative_Pointer,
 	Relative_Slice,
@@ -93,7 +91,6 @@ type_kind :: proc(T: typeid) -> Type_Kind {
 		case Type_Info_Enum:             return .Enum;
 		case Type_Info_Map:              return .Map;
 		case Type_Info_Bit_Set:          return .Bit_Set;
-		case Type_Info_Opaque:           return .Opaque;
 		case Type_Info_Simd_Vector:      return .Simd_Vector;
 		case Type_Info_Relative_Pointer: return .Relative_Pointer;
 		case Type_Info_Relative_Slice:   return .Relative_Slice;
@@ -136,7 +133,6 @@ type_info_core :: proc(info: ^runtime.Type_Info) -> ^runtime.Type_Info {
 		#partial switch i in base.variant {
 		case Type_Info_Named:  base = i.base;
 		case Type_Info_Enum:   base = i.base;
-		case Type_Info_Opaque: base = i.elem;
 		case: break loop;
 		}
 	}
@@ -174,7 +170,6 @@ typeid_elem :: proc(id: typeid) -> typeid {
 		case 256: return f64;
 		}
 	case Type_Info_Pointer:          return v.elem.id;
-	case Type_Info_Opaque:           return v.elem.id;
 	case Type_Info_Array:            return v.elem.id;
 	case Type_Info_Enumerated_Array: return v.elem.id;
 	case Type_Info_Slice:            return v.elem.id;

core/reflect/types.odin

@@ -162,11 +162,6 @@ are_types_identical :: proc(a, b: ^Type_Info) -> bool {
 		if !ok { return false; }
 		return x.elem == y.elem && x.lower == y.lower && x.upper == y.upper;
 
-	case Type_Info_Opaque:
-		y, ok := b.variant.(Type_Info_Opaque);
-		if !ok { return false; }
-		return x.elem == y.elem;
-
 	case Type_Info_Simd_Vector:
 		y, ok := b.variant.(Type_Info_Simd_Vector);
 		if !ok { return false; }
@@ -317,11 +312,6 @@ is_enum :: proc(info: ^Type_Info) -> bool {
 	_, ok := type_info_base(info).variant.(Type_Info_Enum);
 	return ok;
 }
-is_opaque :: proc(info: ^Type_Info) -> bool {
-	if info == nil { return false; }
-	_, ok := type_info_base(info).variant.(Type_Info_Opaque);
-	return ok;
-}
 is_simd_vector :: proc(info: ^Type_Info) -> bool {
 	if info == nil { return false; }
 	_, ok := type_info_base(info).variant.(Type_Info_Simd_Vector);
@@ -574,10 +564,6 @@ write_type_writer :: proc(w: io.Writer, ti: ^Type_Info) -> (n: int) {
 		}
 		n += _n(io.write_byte(w, ']'));
 
-	case Type_Info_Opaque:
-		n += write_string(w, "#opaque ");
-		n += write_type(w, info.elem);
-
 	case Type_Info_Simd_Vector:
 		if info.is_x86_mmx {
 			n += write_string(w, "intrinsics.x86_mmx");

core/runtime/core.odin

@@ -140,9 +140,6 @@ Type_Info_Bit_Set :: struct {
 	lower:      i64,
 	upper:      i64,
 };
-Type_Info_Opaque :: struct {
-	elem: ^Type_Info,
-};
 Type_Info_Simd_Vector :: struct {
 	elem:       ^Type_Info,
 	elem_size:  int,
@@ -193,7 +190,6 @@ Type_Info :: struct {
 		Type_Info_Enum,
 		Type_Info_Map,
 		Type_Info_Bit_Set,
-		Type_Info_Opaque,
 		Type_Info_Simd_Vector,
 		Type_Info_Relative_Pointer,
 		Type_Info_Relative_Slice,
@@ -224,7 +220,6 @@ Typeid_Kind :: enum u8 {
 	Enum,
 	Map,
 	Bit_Set,
-	Opaque,
 	Simd_Vector,
 	Relative_Pointer,
 	Relative_Slice,
@@ -399,7 +394,6 @@ type_info_core :: proc "contextless" (info: ^Type_Info) -> ^Type_Info {
 		#partial switch i in base.variant {
 		case Type_Info_Named:  base = i.base;
 		case Type_Info_Enum:   base = i.base;
-		case Type_Info_Opaque: base = i.elem;
 		case: break loop;
 		}
 	}

core/runtime/print.odin

@@ -345,9 +345,6 @@ print_type :: proc "contextless" (ti: ^Type_Info) {
 		}
 		print_byte(']');
 
-	case Type_Info_Opaque:
-		print_string("#opaque ");
-		print_type(info.elem);
 
 	case Type_Info_Simd_Vector:
 		if info.is_x86_mmx {

src/check_decl.cpp

@@ -209,9 +209,6 @@ bool is_type_distinct(Ast *node) {
 	case Ast_DynamicArrayType:
 	case Ast_MapType:
 		return false;
-
-	case Ast_OpaqueType:
-		return true;
 	}
 	return false;
 }

src/check_expr.cpp

@@ -836,11 +836,6 @@ bool is_polymorphic_type_assignable(CheckerContext *c, Type *poly, Type *source,
 		}
 		return true;
 	}
-	case Type_Opaque:
-		if (source->kind == Type_Opaque) {
-			return is_polymorphic_type_assignable(c, poly->Opaque.elem, source->Opaque.elem, true, modify_type);
-		}
-		return false;
 	case Type_Pointer:
 		if (source->kind == Type_Pointer) {
 			isize level = check_is_assignable_to_using_subtype(source->Pointer.elem, poly->Pointer.elem);
@@ -2312,14 +2307,6 @@ bool check_is_castable_to(CheckerContext *c, Operand *operand, Type *y) {
 	if (is_type_rawptr(src) && is_type_proc(dst)) {
 		return true;
 	}
-
-	if (is_type_opaque(src)) {
-		return are_types_identical(dst, src->Opaque.elem);
-	}
-	if (is_type_opaque(dst)) {
-		return are_types_identical(dst->Opaque.elem, src);
-	}
-
 	return false;
 }
 
@@ -3793,7 +3780,6 @@ BuiltinTypeIsProc *builtin_type_is_procs[BuiltinProc__type_simple_boolean_end -
 
 	is_type_named,
 	is_type_pointer,
-	is_type_opaque,
 	is_type_array,
 	is_type_enumerated_array,
 	is_type_slice,
@@ -5640,7 +5626,6 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32
 				}
 				break;
 			case Type_Pointer:         operand->type = bt->Pointer.elem;         break;
-			case Type_Opaque:          operand->type = bt->Opaque.elem;          break;
 			case Type_Array:           operand->type = bt->Array.elem;           break;
 			case Type_EnumeratedArray: operand->type = bt->EnumeratedArray.elem; break;
 			case Type_Slice:           operand->type = bt->Slice.elem;           break;
@@ -5674,7 +5659,6 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32
 	case BuiltinProc_type_is_valid_map_key:
 	case BuiltinProc_type_is_named:
 	case BuiltinProc_type_is_pointer:
-	case BuiltinProc_type_is_opaque:
 	case BuiltinProc_type_is_array:
 	case BuiltinProc_type_is_slice:
 	case BuiltinProc_type_is_dynamic_array:
@@ -10173,7 +10157,6 @@ ExprKind check_expr_base_internal(CheckerContext *c, Operand *o, Ast *node, Type
 	case Ast_UnionType:
 	case Ast_EnumType:
 	case Ast_MapType:
-	case Ast_OpaqueType:
 	case Ast_BitSetType:
 		o->mode = Addressing_Type;
 		o->type = check_type(c, node);
@@ -10556,11 +10539,6 @@ gbString write_expr_to_string(gbString str, Ast *node, bool shorthand) {
 		str = write_expr_to_string(str, ht->type, shorthand);
 	case_end;
 
-	case_ast_node(ht, OpaqueType, node);
-		str = gb_string_appendc(str, "opaque ");
-		str = write_expr_to_string(str, ht->type, shorthand);
-	case_end;
-
 	case_ast_node(pt, PolyType, node);
 		str = gb_string_append_rune(str, '$');
 		str = write_expr_to_string(str, pt->type, shorthand);

src/check_type.cpp

@@ -3352,13 +3352,6 @@ bool check_type_internal(CheckerContext *ctx, Ast *e, Type **type, Type *named_t
 		return true;
 	case_end;
 
-	case_ast_node(ot, OpaqueType, e);
-		Type *elem = strip_opaque_type(check_type_expr(ctx, ot->type, nullptr));
-		*type = alloc_type_opaque(elem);
-		set_base_type(named_type, *type);
-		return true;
-	case_end;
-
 	case_ast_node(at, ArrayType, e);
 		if (at->count != nullptr) {
 			Operand o = {};

src/checker.cpp

@@ -1346,10 +1346,6 @@ void add_type_info_type(CheckerContext *c, Type *t) {
 		}
 		break;
 
-	case Type_Opaque:
-		add_type_info_type(c, bt->Opaque.elem);
-		break;
-
 	case Type_BitSet:
 		add_type_info_type(c, bt->BitSet.elem);
 		add_type_info_type(c, bt->BitSet.underlying);
@@ -1559,10 +1555,6 @@ void add_min_dep_type_info(Checker *c, Type *t) {
 		}
 		break;
 
-	case Type_Opaque:
-		add_min_dep_type_info(c, bt->Opaque.elem);
-		break;
-
 	case Type_BitSet:
 		add_min_dep_type_info(c, bt->BitSet.elem);
 		add_min_dep_type_info(c, bt->BitSet.underlying);
@@ -2209,7 +2201,6 @@ void init_core_type_info(Checker *c) {
 	t_type_info_enum             = find_core_type(c, str_lit("Type_Info_Enum"));
 	t_type_info_map              = find_core_type(c, str_lit("Type_Info_Map"));
 	t_type_info_bit_set          = find_core_type(c, str_lit("Type_Info_Bit_Set"));
-	t_type_info_opaque           = find_core_type(c, str_lit("Type_Info_Opaque"));
 	t_type_info_simd_vector      = find_core_type(c, str_lit("Type_Info_Simd_Vector"));
 	t_type_info_relative_pointer = find_core_type(c, str_lit("Type_Info_Relative_Pointer"));
 	t_type_info_relative_slice   = find_core_type(c, str_lit("Type_Info_Relative_Slice"));
@@ -2236,7 +2227,6 @@ void init_core_type_info(Checker *c) {
 	t_type_info_enum_ptr             = alloc_type_pointer(t_type_info_enum);
 	t_type_info_map_ptr              = alloc_type_pointer(t_type_info_map);
 	t_type_info_bit_set_ptr          = alloc_type_pointer(t_type_info_bit_set);
-	t_type_info_opaque_ptr           = alloc_type_pointer(t_type_info_opaque);
 	t_type_info_simd_vector_ptr      = alloc_type_pointer(t_type_info_simd_vector);
 	t_type_info_relative_pointer_ptr = alloc_type_pointer(t_type_info_relative_pointer);
 	t_type_info_relative_slice_ptr   = alloc_type_pointer(t_type_info_relative_slice);

src/checker_builtin_procs.hpp

@@ -146,7 +146,6 @@ BuiltinProc__type_simple_boolean_begin,
 
 	BuiltinProc_type_is_named,
 	BuiltinProc_type_is_pointer,
-	BuiltinProc_type_is_opaque,
 	BuiltinProc_type_is_array,
 	BuiltinProc_type_is_enumerated_array,
 	BuiltinProc_type_is_slice,
@@ -335,7 +334,6 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = {
 
 	{STR_LIT("type_is_named"),             1, false, Expr_Expr, BuiltinProcPkg_intrinsics},
 	{STR_LIT("type_is_pointer"),           1, false, Expr_Expr, BuiltinProcPkg_intrinsics},
-	{STR_LIT("type_is_opaque"),            1, false, Expr_Expr, BuiltinProcPkg_intrinsics},
 	{STR_LIT("type_is_array"),             1, false, Expr_Expr, BuiltinProcPkg_intrinsics},
 	{STR_LIT("type_is_enumerated_array"),  1, false, Expr_Expr, BuiltinProcPkg_intrinsics},
 	{STR_LIT("type_is_slice"),             1, false, Expr_Expr, BuiltinProcPkg_intrinsics},

src/ir.cpp

@@ -2603,10 +2603,6 @@ irDebugInfo *ir_add_debug_info_type(irModule *module, Type *type, Entity *e, irD
 		return di;
 	}
 
-	if (is_type_opaque(type)) {
-		return ir_add_debug_info_type(module, strip_opaque_type(type), e, scope, file);
-	}
-
 	if (is_type_struct(type) ||
 	    is_type_union(type) || is_type_enum(type) || is_type_tuple(type)) {
 		if (type->kind == Type_Named) {
@@ -5302,10 +5298,6 @@ irValue *ir_emit_struct_ep(irProcedure *proc, irValue *s, i32 index) {
 	Type *t = base_type(type_deref(ir_type(s)));
 	Type *result_type = nullptr;
 
-	if (t->kind == Type_Opaque) {
-		t = t->Opaque.elem;
-	}
-
 	if (is_type_relative_pointer(t)) {
 		s = ir_addr_get_ptr(proc, ir_addr(s));
 	}
@@ -5498,9 +5490,6 @@ irValue *ir_emit_deep_field_gep(irProcedure *proc, irValue *e, Selection sel) {
 			// e = ir_emit_ptr_offset(proc, e, v_zero); // TODO(bill): Do I need these copies?
 		}
 		type = core_type(type);
-		if (type->kind == Type_Opaque) {
-			type = type->Opaque.elem;
-		}
 
 		if (is_type_quaternion(type)) {
 			e = ir_emit_struct_ep(proc, e, index);
@@ -12505,12 +12494,6 @@ void ir_setup_type_info_data(irProcedure *proc) { // NOTE(bill): Setup type_info
 			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 3), ir_const_i64(t->BitSet.upper));
 			break;
 
-		case Type_Opaque:
-			ir_emit_comment(proc, str_lit("Type_Opaque"));
-			tag = ir_emit_conv(proc, variant_ptr, t_type_info_opaque_ptr);
-			ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), ir_get_type_info_ptr(proc, t->Opaque.elem));
-			break;
-
 		case Type_SimdVector:
 			ir_emit_comment(proc, str_lit("Type_SimdVector"));
 			tag = ir_emit_conv(proc, variant_ptr, t_type_info_simd_vector_ptr);

src/ir_print.cpp

@@ -645,10 +645,6 @@ void ir_print_type(irFileBuffer *f, irModule *m, Type *t, bool in_struct) {
 		return;
 	}
 
-	case Type_Opaque:
-		ir_print_type(f, m, strip_opaque_type(t));
-		return;
-
 	case Type_SimdVector:
 		if (t->SimdVector.is_x86_mmx) {
 			ir_write_str_lit(f, "x86_mmx");

src/llvm_backend.cpp

@@ -1095,9 +1095,6 @@ LLVMTypeRef lb_type_internal(lbModule *m, Type *type) {
 				GB_PANIC("INVALID TYPE");
 				break;
 
-			case Type_Opaque:
-				return lb_type_internal(m, base->Opaque.elem);
-
 			case Type_Pointer:
 			case Type_Array:
 			case Type_EnumeratedArray:
@@ -1156,9 +1153,6 @@ LLVMTypeRef lb_type_internal(lbModule *m, Type *type) {
 	case Type_Pointer:
 		return LLVMPointerType(lb_type(m, type_deref(type)), 0);
 
-	case Type_Opaque:
-		return lb_type(m, base_type(type));
-
 	case Type_Array:
 		return LLVMArrayType(lb_type(m, type->Array.elem), cast(unsigned)type->Array.count);
 
@@ -1742,10 +1736,6 @@ LLVMMetadataRef lb_debug_type_internal(lbModule *m, Type *type) {
 		return nullptr;
 		// return LLVMPointerType(lb_type(m, type_deref(type)), 0);
 
-	case Type_Opaque:
-		return nullptr;
-		// return lb_type(m, base_type(type));
-
 	case Type_Array:
 		return nullptr;
 		// return LLVMArrayType(lb_type(m, type->Array.elem), cast(unsigned)type->Array.count);
@@ -4881,7 +4871,6 @@ lbValue lb_typeid(lbModule *m, Type *type) {
 	case Type_Tuple:           kind = Typeid_Tuple;            break;
 	case Type_Proc:            kind = Typeid_Procedure;        break;
 	case Type_BitSet:          kind = Typeid_Bit_Set;          break;
-	case Type_Opaque:          kind = Typeid_Opaque;           break;
 	case Type_SimdVector:      kind = Typeid_Simd_Vector;      break;
 	case Type_RelativePointer: kind = Typeid_Relative_Pointer; break;
 	case Type_RelativeSlice:   kind = Typeid_Relative_Slice;   break;
@@ -6861,10 +6850,6 @@ lbValue lb_emit_struct_ep(lbProcedure *p, lbValue s, i32 index) {
 	Type *t = base_type(type_deref(s.type));
 	Type *result_type = nullptr;
 
-	if (t->kind == Type_Opaque) {
-		t = t->Opaque.elem;
-	}
-
 	if (is_type_relative_pointer(t)) {
 		s = lb_addr_get_ptr(p, lb_addr(s));
 	}
@@ -7077,9 +7062,6 @@ lbValue lb_emit_deep_field_gep(lbProcedure *p, lbValue e, Selection sel) {
 			e = lb_emit_load(p, e);
 		}
 		type = core_type(type);
-		if (type->kind == Type_Opaque) {
-			type = type->Opaque.elem;
-		}
 
 		if (is_type_quaternion(type)) {
 			e = lb_emit_struct_ep(p, e, index);
@@ -12409,19 +12391,6 @@ void lb_setup_type_info_data(lbProcedure *p) { // NOTE(bill): Setup type_info da
 			}
 			break;
 
-		case Type_Opaque:
-			{
-				tag = lb_const_ptr_cast(m, variant_ptr, t_type_info_opaque_ptr);
-				LLVMValueRef vals[1] = {
-					lb_get_type_info_ptr(m, t->Opaque.elem).value,
-				};
-
-				lbValue res = {};
-				res.type = type_deref(tag.type);
-				res.value = LLVMConstNamedStruct(lb_type(m, res.type), vals, gb_count_of(vals));
-				lb_emit_store(p, tag, res);
-			}
-			break;
 		case Type_SimdVector:
 			{
 				tag = lb_const_ptr_cast(m, variant_ptr, t_type_info_simd_vector_ptr);

src/parser.cpp

@@ -90,7 +90,6 @@ Token ast_token(Ast *node) {
 	case Ast_TypeidType:       return node->TypeidType.token;
 	case Ast_HelperType:       return node->HelperType.token;
 	case Ast_DistinctType:     return node->DistinctType.token;
-	case Ast_OpaqueType:       return node->OpaqueType.token;
 	case Ast_PolyType:         return node->PolyType.token;
 	case Ast_ProcType:         return node->ProcType.token;
 	case Ast_RelativeType:     return ast_token(node->RelativeType.tag);
@@ -380,9 +379,6 @@ Ast *clone_ast(Ast *node) {
 	case Ast_DistinctType:
 		n->DistinctType.type = clone_ast(n->DistinctType.type);
 		break;
-	case Ast_OpaqueType:
-		n->OpaqueType.type = clone_ast(n->OpaqueType.type);
-		break;
 	case Ast_ProcType:
 		n->ProcType.params  = clone_ast(n->ProcType.params);
 		n->ProcType.results = clone_ast(n->ProcType.results);
@@ -952,12 +948,6 @@ Ast *ast_distinct_type(AstFile *f, Token token, Ast *type) {
 	return result;
 }
 
-Ast *ast_opaque_type(AstFile *f, Token token, Ast *type) {
-	Ast *result = alloc_ast_node(f, Ast_OpaqueType);
-	result->OpaqueType.token = token;
-	result->OpaqueType.type  = type;
-	return result;
-}
 
 Ast *ast_poly_type(AstFile *f, Token token, Ast *type, Ast *specialization) {
 	Ast *result = alloc_ast_node(f, Ast_PolyType);
@@ -2009,8 +1999,8 @@ Ast *parse_operand(AstFile *f, bool lhs) {
 			Ast *type = parse_type(f);
 			return ast_relative_type(f, tag, type);
 		} else if (name.string == "opaque") {
-			Ast *type = parse_type(f);
-			return ast_opaque_type(f, token, type);
+			syntax_warning(token, "'#opaque' has been removed and will do nothing to the applied type");
+			return parse_type(f);
 		} else if (name.string == "force_inline" ||
 		           name.string == "force_no_inline") {
 			return parse_force_inlining_operand(f, name);

src/parser.hpp

@@ -530,10 +530,6 @@ AST_KIND(_TypeBegin, "", bool) \
 		Token token; \
 		Ast *type; \
 	}) \
-	AST_KIND(OpaqueType, "opaque type", struct { \
-		Token token; \
-		Ast *type; \
-	}) \
 	AST_KIND(PolyType, "polymorphic type", struct { \
 		Token token; \
 		Ast * type;  \

src/query_data.cpp

@@ -597,7 +597,6 @@ void generate_and_print_query_data_global_definitions(Checker *c, Timings *timin
 					Type *bt = base_type(t);
 					switch (bt->kind) {
 					case Type_Pointer:      type_kind = str_lit("pointer");       break;
-					case Type_Opaque:       type_kind = str_lit("opaque");        break;
 					case Type_Array:        type_kind = str_lit("array");         break;
 					case Type_Slice:        type_kind = str_lit("slice");         break;
 					case Type_DynamicArray: type_kind = str_lit("dynamic array"); break;

src/types.cpp

@@ -227,7 +227,6 @@ struct TypeProc {
 		Entity *entity;                                   \
 	})                                                    \
 	TYPE_KIND(Pointer, struct { Type *elem; })            \
-	TYPE_KIND(Opaque,  struct { Type *elem; })            \
 	TYPE_KIND(Array,   struct {                           \
 		Type *elem;                                       \
 		i64   count;                                      \
@@ -358,7 +357,6 @@ enum Typeid_Kind : u8 {
 	Typeid_Enum,
 	Typeid_Map,
 	Typeid_Bit_Set,
-	Typeid_Opaque,
 	Typeid_Simd_Vector,
 	Typeid_Relative_Pointer,
 	Typeid_Relative_Slice,
@@ -633,7 +631,6 @@ gb_global Type *t_type_info_union                = nullptr;
 gb_global Type *t_type_info_enum                 = nullptr;
 gb_global Type *t_type_info_map                  = nullptr;
 gb_global Type *t_type_info_bit_set              = nullptr;
-gb_global Type *t_type_info_opaque               = nullptr;
 gb_global Type *t_type_info_simd_vector          = nullptr;
 gb_global Type *t_type_info_relative_pointer     = nullptr;
 gb_global Type *t_type_info_relative_slice       = nullptr;
@@ -660,7 +657,6 @@ gb_global Type *t_type_info_union_ptr            = nullptr;
 gb_global Type *t_type_info_enum_ptr             = nullptr;
 gb_global Type *t_type_info_map_ptr              = nullptr;
 gb_global Type *t_type_info_bit_set_ptr          = nullptr;
-gb_global Type *t_type_info_opaque_ptr           = nullptr;
 gb_global Type *t_type_info_simd_vector_ptr      = nullptr;
 gb_global Type *t_type_info_relative_pointer_ptr = nullptr;
 gb_global Type *t_type_info_relative_slice_ptr   = nullptr;
@@ -729,19 +725,6 @@ Type *base_type(Type *t) {
 	return t;
 }
 
-Type *strip_opaque_type(Type *t) {
-	for (;;) {
-		if (t == nullptr) {
-			break;
-		}
-		if (t->kind != Type_Opaque) {
-			break;
-		}
-		t = t->Opaque.elem;
-	}
-	return t;
-}
-
 Type *base_enum_type(Type *t) {
 	Type *bt = base_type(t);
 	if (bt != nullptr &&
@@ -767,9 +750,6 @@ Type *core_type(Type *t) {
 		case Type_Enum:
 			t = t->Enum.base_type;
 			continue;
-		case Type_Opaque:
-			t = t->Opaque.elem;
-			continue;
 		}
 		break;
 	}
@@ -804,12 +784,6 @@ Type *alloc_type_generic(Scope *scope, i64 id, String name, Type *specialized) {
 	return t;
 }
 
-Type *alloc_type_opaque(Type *elem) {
-	Type *t = alloc_type(Type_Opaque);
-	t->Opaque.elem = elem;
-	return t;
-}
-
 Type *alloc_type_pointer(Type *elem) {
 	Type *t = alloc_type(Type_Pointer);
 	t->Pointer.elem = elem;
@@ -1177,10 +1151,6 @@ bool is_type_tuple(Type *t) {
 	t = base_type(t);
 	return t->kind == Type_Tuple;
 }
-bool is_type_opaque(Type *t) {
-	t = base_type(t);
-	return t->kind == Type_Opaque;
-}
 bool is_type_uintptr(Type *t) {
 	if (t->kind == Type_Basic) {
 		return (t->Basic.kind == Basic_uintptr);
@@ -1710,8 +1680,6 @@ bool is_type_polymorphic(Type *t, bool or_specialized=false) {
 			return ok;
 		}
 
-	case Type_Opaque:
-		return is_type_polymorphic(t->Opaque.elem, or_specialized);
 	case Type_Pointer:
 		return is_type_polymorphic(t->Pointer.elem, or_specialized);
 
@@ -1841,8 +1809,6 @@ bool type_has_nil(Type *t) {
 			}
 		}
 		return false;
-	case Type_Opaque:
-		return true;
 
 	case Type_RelativePointer:
 	case Type_RelativeSlice:
@@ -1895,9 +1861,6 @@ bool is_type_comparable(Type *t) {
 	case Type_BitSet:
 		return true;
 
-	case Type_Opaque:
-		return is_type_comparable(t->Opaque.elem);
-
 	case Type_Struct:
 		if (type_size_of(t) == 0) {
 			return false;
@@ -2000,12 +1963,6 @@ bool are_types_identical(Type *x, Type *y) {
 		}
 		break;
 
-	case Type_Opaque:
-		if (y->kind == Type_Opaque) {
-			return are_types_identical(x->Opaque.elem, y->Opaque.elem);
-		}
-		break;
-
 	case Type_Basic:
 		if (y->kind == Type_Basic) {
 			return x->Basic.kind == y->Basic.kind;
@@ -2832,9 +2789,6 @@ i64 type_align_of_internal(Type *t, TypePath *path) {
 		return align;
 	}
 
-	case Type_Opaque:
-		return type_align_of_internal(t->Opaque.elem, path);
-
 	case Type_DynamicArray:
 		// data, count, capacity, allocator
 		return build_context.word_size;
@@ -3049,9 +3003,6 @@ i64 type_size_of_internal(Type *t, TypePath *path) {
 	case Type_Pointer:
 		return build_context.word_size;
 
-	case Type_Opaque:
-		return type_size_of_internal(t->Opaque.elem, path);
-
 	case Type_Array: {
 		i64 count, align, size, alignment;
 		count = t->Array.count;
@@ -3425,11 +3376,6 @@ gbString write_type_to_string(gbString str, Type *type) {
 		str = write_type_to_string(str, type->Pointer.elem);
 		break;
 
-	case Type_Opaque:
-		str = gb_string_appendc(str, "opaque ");
-		str = write_type_to_string(str, type->Opaque.elem);
-		break;
-
 	case Type_EnumeratedArray:
 		str = gb_string_append_rune(str, '[');
 		str = write_type_to_string(str, type->EnumeratedArray.index);