ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-07-30 03:10:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove #opaque types

Browse Source
This commit is contained in:
gingerBill
2021-02-23 15:45:06 +00:00
parent 28f279329d
commit 41b854f192
23 changed files with 2 additions and 262 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/check_decl.cpp
-3
View File
@@ -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
-22
View File
@@ -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
-7
View File
@@ -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
-10
View File
@@ -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
-2
View File
@@ -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
-17
View File
@@ -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
-4
View File
@@ -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
-31
View File
@@ -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
+2 -12
View File
@@ -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
-4
View File
@@ -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
-1
View File
@@ -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
-54
View File
@@ -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);