diff --git a/doc/langref.html.in b/doc/langref.html.in
index 16fafdaad9ab..b867ff0b3523 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -4809,6 +4809,182 @@ pub const TypeId = enum {
BoundFn,
ArgTuple,
Opaque,
+};
+ {#code_end#}
+ {#header_close#}
+ {#header_open|@typeInfo#}
+ @typeInfo(comptime T: type) -> @import("builtin").TypeInfo
+
+ Returns information on the type. Returns a value of the following union:
+
+ {#code_begin|syntax#}
+pub const TypeInfo = union(TypeId) {
+ Type: void,
+ Void: void,
+ Bool: void,
+ NoReturn: void,
+ Int: Int,
+ Float: Float,
+ Pointer: Pointer,
+ Array: Array,
+ Struct: Struct,
+ FloatLiteral: void,
+ IntLiteral: void,
+ UndefinedLiteral: void,
+ NullLiteral: void,
+ Nullable: Nullable,
+ ErrorUnion: ErrorUnion,
+ ErrorSet: ErrorSet,
+ Enum: Enum,
+ Union: Union,
+ Fn: Fn,
+ Namespace: void,
+ Block: void,
+ BoundFn: Fn,
+ ArgTuple: void,
+ Opaque: void,
+ Promise: Promise,
+
+
+ pub const Int = struct {
+ is_signed: bool,
+ bits: u8,
+ };
+
+ pub const Float = struct {
+ bits: u8,
+ };
+
+ pub const Pointer = struct {
+ is_const: bool,
+ is_volatile: bool,
+ alignment: u32,
+ child: type,
+ };
+
+ pub const Array = struct {
+ len: usize,
+ child: type,
+ };
+
+ pub const ContainerLayout = enum {
+ Auto,
+ Extern,
+ Packed,
+ };
+
+ pub const StructField = struct {
+ name: []const u8,
+ offset: ?usize,
+ field_type: type,
+ };
+
+ pub const Struct = struct {
+ layout: ContainerLayout,
+ fields: []StructField,
+ defs: []Definition,
+ };
+
+ pub const Nullable = struct {
+ child: type,
+ };
+
+ pub const ErrorUnion = struct {
+ error_set: type,
+ payload: type,
+ };
+
+ pub const Error = struct {
+ name: []const u8,
+ value: usize,
+ };
+
+ pub const ErrorSet = struct {
+ errors: []Error,
+ };
+
+ pub const EnumField = struct {
+ name: []const u8,
+ value: usize,
+ };
+
+ pub const Enum = struct {
+ layout: ContainerLayout,
+ tag_type: type,
+ fields: []EnumField,
+ defs: []Definition,
+ };
+
+ pub const UnionField = struct {
+ name: []const u8,
+ enum_field: ?EnumField,
+ field_type: type,
+ };
+
+ pub const Union = struct {
+ layout: ContainerLayout,
+ tag_type: type,
+ fields: []UnionField,
+ defs: []Definition,
+ };
+
+ pub const CallingConvention = enum {
+ Unspecified,
+ C,
+ Cold,
+ Naked,
+ Stdcall,
+ Async,
+ };
+
+ pub const FnArg = struct {
+ is_generic: bool,
+ is_noalias: bool,
+ arg_type: type,
+ };
+
+ pub const Fn = struct {
+ calling_convention: CallingConvention,
+ is_generic: bool,
+ is_var_args: bool,
+ return_type: type,
+ async_allocator_type: type,
+ args: []FnArg,
+ };
+
+ pub const Promise = struct {
+ child: type,
+ };
+
+ pub const Definition = struct {
+ name: []const u8,
+ is_pub: bool,
+ data: Data,
+
+ pub const Data = union(enum) {
+ Type: type,
+ Var: type,
+ Fn: FnDef,
+
+ pub const FnDef = struct {
+ fn_type: type,
+ inline_type: Inline,
+ calling_convention: CallingConvention,
+ is_var_args: bool,
+ is_extern: bool,
+ is_export: bool,
+ lib_name: ?[]const u8,
+ return_type: type,
+ arg_names: [][] const u8,
+
+ pub const Inline = enum {
+ Auto,
+ Always,
+ Never,
+ };
+ };
+ };
+ };
};
{#code_end#}
{#header_close#}
@@ -5226,7 +5402,6 @@ pub const Os = enum {
rtems,
nacl,
cnk,
- bitrig,
aix,
cuda,
nvcl,
@@ -5237,10 +5412,12 @@ pub const Os = enum {
watchos,
mesa3d,
contiki,
+ amdpal,
zen,
};
pub const Arch = enum {
+ armv8_3a,
armv8_2a,
armv8_1a,
armv8,
@@ -5260,9 +5437,29 @@ pub const Arch = enum {
armv5,
armv5te,
armv4t,
- armeb,
+ armebv8_3a,
+ armebv8_2a,
+ armebv8_1a,
+ armebv8,
+ armebv8r,
+ armebv8m_baseline,
+ armebv8m_mainline,
+ armebv7,
+ armebv7em,
+ armebv7m,
+ armebv7s,
+ armebv7k,
+ armebv7ve,
+ armebv6,
+ armebv6m,
+ armebv6k,
+ armebv6t2,
+ armebv5,
+ armebv5te,
+ armebv4t,
aarch64,
aarch64_be,
+ arc,
avr,
bpfel,
bpfeb,
@@ -5315,6 +5512,7 @@ pub const Arch = enum {
pub const Environ = enum {
unknown,
gnu,
+ gnuabin32,
gnuabi64,
gnueabi,
gnueabihf,
@@ -5332,6 +5530,7 @@ pub const Environ = enum {
amdopencl,
coreclr,
opencl,
+ simulator,
};
pub const ObjectFormat = enum {
@@ -5358,10 +5557,23 @@ pub const AtomicOrder = enum {
SeqCst,
};
+pub const AtomicRmwOp = enum {
+ Xchg,
+ Add,
+ Sub,
+ And,
+ Nand,
+ Or,
+ Xor,
+ Max,
+ Min,
+};
+
pub const Mode = enum {
Debug,
ReleaseSafe,
ReleaseFast,
+ ReleaseSmall,
};
pub const TypeId = enum {
@@ -5380,7 +5592,7 @@ pub const TypeId = enum {
NullLiteral,
Nullable,
ErrorUnion,
- Error,
+ ErrorSet,
Enum,
Union,
Fn,
@@ -5389,6 +5601,176 @@ pub const TypeId = enum {
BoundFn,
ArgTuple,
Opaque,
+ Promise,
+};
+
+pub const TypeInfo = union(TypeId) {
+ Type: void,
+ Void: void,
+ Bool: void,
+ NoReturn: void,
+ Int: Int,
+ Float: Float,
+ Pointer: Pointer,
+ Array: Array,
+ Struct: Struct,
+ FloatLiteral: void,
+ IntLiteral: void,
+ UndefinedLiteral: void,
+ NullLiteral: void,
+ Nullable: Nullable,
+ ErrorUnion: ErrorUnion,
+ ErrorSet: ErrorSet,
+ Enum: Enum,
+ Union: Union,
+ Fn: Fn,
+ Namespace: void,
+ Block: void,
+ BoundFn: Fn,
+ ArgTuple: void,
+ Opaque: void,
+ Promise: Promise,
+
+
+ pub const Int = struct {
+ is_signed: bool,
+ bits: u8,
+ };
+
+ pub const Float = struct {
+ bits: u8,
+ };
+
+ pub const Pointer = struct {
+ is_const: bool,
+ is_volatile: bool,
+ alignment: u32,
+ child: type,
+ };
+
+ pub const Array = struct {
+ len: usize,
+ child: type,
+ };
+
+ pub const ContainerLayout = enum {
+ Auto,
+ Extern,
+ Packed,
+ };
+
+ pub const StructField = struct {
+ name: []const u8,
+ offset: ?usize,
+ field_type: type,
+ };
+
+ pub const Struct = struct {
+ layout: ContainerLayout,
+ fields: []StructField,
+ defs: []Definition,
+ };
+
+ pub const Nullable = struct {
+ child: type,
+ };
+
+ pub const ErrorUnion = struct {
+ error_set: type,
+ payload: type,
+ };
+
+ pub const Error = struct {
+ name: []const u8,
+ value: usize,
+ };
+
+ pub const ErrorSet = struct {
+ errors: []Error,
+ };
+
+ pub const EnumField = struct {
+ name: []const u8,
+ value: usize,
+ };
+
+ pub const Enum = struct {
+ layout: ContainerLayout,
+ tag_type: type,
+ fields: []EnumField,
+ defs: []Definition,
+ };
+
+ pub const UnionField = struct {
+ name: []const u8,
+ enum_field: ?EnumField,
+ field_type: type,
+ };
+
+ pub const Union = struct {
+ layout: ContainerLayout,
+ tag_type: type,
+ fields: []UnionField,
+ defs: []Definition,
+ };
+
+ pub const CallingConvention = enum {
+ Unspecified,
+ C,
+ Cold,
+ Naked,
+ Stdcall,
+ Async,
+ };
+
+ pub const FnArg = struct {
+ is_generic: bool,
+ is_noalias: bool,
+ arg_type: type,
+ };
+
+ pub const Fn = struct {
+ calling_convention: CallingConvention,
+ is_generic: bool,
+ is_var_args: bool,
+ return_type: type,
+ async_allocator_type: type,
+ args: []FnArg,
+ };
+
+ pub const Promise = struct {
+ child: type,
+ };
+
+ pub const Definition = struct {
+ name: []const u8,
+ is_pub: bool,
+ data: Data,
+
+ pub const Data = union(enum) {
+ Type: type,
+ Var: type,
+ Fn: FnDef,
+
+ pub const FnDef = struct {
+ fn_type: type,
+ inline_type: Inline,
+ calling_convention: CallingConvention,
+ is_var_args: bool,
+ is_extern: bool,
+ is_export: bool,
+ lib_name: ?[]const u8,
+ return_type: type,
+ arg_names: [][] const u8,
+
+ pub const Inline = enum {
+ Auto,
+ Always,
+ Never,
+ };
+ };
+ };
+ };
};
pub const FloatMode = enum {
@@ -5402,7 +5784,7 @@ pub const Endian = enum {
};
pub const endian = Endian.Little;
-pub const is_test = false;
+pub const is_test = true;
pub const os = Os.linux;
pub const arch = Arch.x86_64;
pub const environ = Environ.gnu;
@@ -5410,6 +5792,7 @@ pub const object_format = ObjectFormat.elf;
pub const mode = Mode.Debug;
pub const link_libc = false;
pub const have_error_return_tracing = true;
+pub const __zig_test_fn_slice = {}; // overwritten later
{#code_end#}
{#see_also|Build Mode#}
{#header_close#}
@@ -6068,7 +6451,7 @@ hljs.registerLanguage("zig", function(t) {
a = t.IR + "\\s*\\(",
c = {
keyword: "const align var extern stdcallcc nakedcc volatile export pub noalias inline struct packed enum union break return try catch test continue unreachable comptime and or asm defer errdefer if else switch while for fn use bool f32 f64 void type noreturn error i8 u8 i16 u16 i32 u32 i64 u64 isize usize i8w u8w i16w i32w u32w i64w u64w isizew usizew c_short c_ushort c_int c_uint c_long c_ulong c_longlong c_ulonglong",
- built_in: "atomicLoad breakpoint returnAddress frameAddress fieldParentPtr setFloatMode IntType OpaqueType compileError compileLog setCold setRuntimeSafety setEvalBranchQuota offsetOf memcpy inlineCall setGlobalLinkage setGlobalSection divTrunc divFloor enumTagName intToPtr ptrToInt panic canImplicitCast ptrCast bitCast rem mod memset sizeOf alignOf alignCast maxValue minValue memberCount memberName memberType typeOf addWithOverflow subWithOverflow mulWithOverflow shlWithOverflow shlExact shrExact cInclude cDefine cUndef ctz clz import cImport errorName embedFile cmpxchgStrong cmpxchgWeak fence divExact truncate atomicRmw sqrt field",
+ built_in: "atomicLoad breakpoint returnAddress frameAddress fieldParentPtr setFloatMode IntType OpaqueType compileError compileLog setCold setRuntimeSafety setEvalBranchQuota offsetOf memcpy inlineCall setGlobalLinkage setGlobalSection divTrunc divFloor enumTagName intToPtr ptrToInt panic canImplicitCast ptrCast bitCast rem mod memset sizeOf alignOf alignCast maxValue minValue memberCount memberName memberType typeOf addWithOverflow subWithOverflow mulWithOverflow shlWithOverflow shlExact shrExact cInclude cDefine cUndef ctz clz import cImport errorName embedFile cmpxchgStrong cmpxchgWeak fence divExact truncate atomicRmw sqrt field typeInfo",
literal: "true false null undefined"
},
n = [e, t.CLCM, t.CBCM, s, r];
diff --git a/src/all_types.hpp b/src/all_types.hpp
index d1b2ad61d260..c1c6c9a1a598 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -1293,6 +1293,7 @@ enum BuiltinFnId {
BuiltinFnIdMemberType,
BuiltinFnIdMemberName,
BuiltinFnIdField,
+ BuiltinFnIdTypeInfo,
BuiltinFnIdTypeof,
BuiltinFnIdAddWithOverflow,
BuiltinFnIdSubWithOverflow,
@@ -1506,6 +1507,7 @@ struct CodeGen {
HashMap exported_symbol_names;
HashMap external_prototypes;
HashMap string_literals_table;
+ HashMap type_info_cache;
ZigList import_queue;
@@ -2037,6 +2039,7 @@ enum IrInstructionId {
IrInstructionIdTagType,
IrInstructionIdFieldParentPtr,
IrInstructionIdOffsetOf,
+ IrInstructionIdTypeInfo,
IrInstructionIdTypeId,
IrInstructionIdSetEvalBranchQuota,
IrInstructionIdPtrTypeOf,
@@ -2858,6 +2861,12 @@ struct IrInstructionOffsetOf {
IrInstruction *field_name;
};
+struct IrInstructionTypeInfo {
+ IrInstruction base;
+
+ IrInstruction *type_value;
+};
+
struct IrInstructionTypeId {
IrInstruction base;
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 2d8c385f44dd..db69708e9a21 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -88,6 +88,7 @@ CodeGen *codegen_create(Buf *root_src_path, const ZigTarget *target, OutType out
g->exported_symbol_names.init(8);
g->external_prototypes.init(8);
g->string_literals_table.init(16);
+ g->type_info_cache.init(32);
g->is_test_build = false;
g->want_h_file = (out_type == OutTypeObj || out_type == OutTypeLib);
buf_resize(&g->global_asm, 0);
@@ -4502,6 +4503,7 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
case IrInstructionIdDeclRef:
case IrInstructionIdSwitchVar:
case IrInstructionIdOffsetOf:
+ case IrInstructionIdTypeInfo:
case IrInstructionIdTypeId:
case IrInstructionIdSetEvalBranchQuota:
case IrInstructionIdPtrTypeOf:
@@ -6125,6 +6127,7 @@ static void define_builtin_fns(CodeGen *g) {
create_builtin_fn(g, BuiltinFnIdMemberType, "memberType", 2);
create_builtin_fn(g, BuiltinFnIdMemberName, "memberName", 2);
create_builtin_fn(g, BuiltinFnIdField, "field", 2);
+ create_builtin_fn(g, BuiltinFnIdTypeInfo, "typeInfo", 1);
create_builtin_fn(g, BuiltinFnIdTypeof, "typeOf", 1); // TODO rename to TypeOf
create_builtin_fn(g, BuiltinFnIdAddWithOverflow, "addWithOverflow", 4);
create_builtin_fn(g, BuiltinFnIdSubWithOverflow, "subWithOverflow", 4);
@@ -6344,6 +6347,190 @@ static void define_builtin_compile_vars(CodeGen *g) {
}
buf_appendf(contents, "};\n\n");
}
+ {
+ buf_appendf(contents,
+ "pub const TypeInfo = union(TypeId) {\n"
+ " Type: void,\n"
+ " Void: void,\n"
+ " Bool: void,\n"
+ " NoReturn: void,\n"
+ " Int: Int,\n"
+ " Float: Float,\n"
+ " Pointer: Pointer,\n"
+ " Array: Array,\n"
+ " Struct: Struct,\n"
+ " FloatLiteral: void,\n"
+ " IntLiteral: void,\n"
+ " UndefinedLiteral: void,\n"
+ " NullLiteral: void,\n"
+ " Nullable: Nullable,\n"
+ " ErrorUnion: ErrorUnion,\n"
+ " ErrorSet: ErrorSet,\n"
+ " Enum: Enum,\n"
+ " Union: Union,\n"
+ " Fn: Fn,\n"
+ " Namespace: void,\n"
+ " Block: void,\n"
+ " BoundFn: Fn,\n"
+ " ArgTuple: void,\n"
+ " Opaque: void,\n"
+ " Promise: Promise,\n"
+ "\n\n"
+ " pub const Int = struct {\n"
+ " is_signed: bool,\n"
+ " bits: u8,\n"
+ " };\n"
+ "\n"
+ " pub const Float = struct {\n"
+ " bits: u8,\n"
+ " };\n"
+ "\n"
+ " pub const Pointer = struct {\n"
+ " is_const: bool,\n"
+ " is_volatile: bool,\n"
+ " alignment: u32,\n"
+ " child: type,\n"
+ " };\n"
+ "\n"
+ " pub const Array = struct {\n"
+ " len: usize,\n"
+ " child: type,\n"
+ " };\n"
+ "\n"
+ " pub const ContainerLayout = enum {\n"
+ " Auto,\n"
+ " Extern,\n"
+ " Packed,\n"
+ " };\n"
+ "\n"
+ " pub const StructField = struct {\n"
+ " name: []const u8,\n"
+ " offset: ?usize,\n"
+ " field_type: type,\n"
+ " };\n"
+ "\n"
+ " pub const Struct = struct {\n"
+ " layout: ContainerLayout,\n"
+ " fields: []StructField,\n"
+ " defs: []Definition,\n"
+ " };\n"
+ "\n"
+ " pub const Nullable = struct {\n"
+ " child: type,\n"
+ " };\n"
+ "\n"
+ " pub const ErrorUnion = struct {\n"
+ " error_set: type,\n"
+ " payload: type,\n"
+ " };\n"
+ "\n"
+ " pub const Error = struct {\n"
+ " name: []const u8,\n"
+ " value: usize,\n"
+ " };\n"
+ "\n"
+ " pub const ErrorSet = struct {\n"
+ " errors: []Error,\n"
+ " };\n"
+ "\n"
+ " pub const EnumField = struct {\n"
+ " name: []const u8,\n"
+ " value: usize,\n"
+ " };\n"
+ "\n"
+ " pub const Enum = struct {\n"
+ " layout: ContainerLayout,\n"
+ " tag_type: type,\n"
+ " fields: []EnumField,\n"
+ " defs: []Definition,\n"
+ " };\n"
+ "\n"
+ " pub const UnionField = struct {\n"
+ " name: []const u8,\n"
+ " enum_field: ?EnumField,\n"
+ " field_type: type,\n"
+ " };\n"
+ "\n"
+ " pub const Union = struct {\n"
+ " layout: ContainerLayout,\n"
+ " tag_type: type,\n"
+ " fields: []UnionField,\n"
+ " defs: []Definition,\n"
+ " };\n"
+ "\n"
+ " pub const CallingConvention = enum {\n"
+ " Unspecified,\n"
+ " C,\n"
+ " Cold,\n"
+ " Naked,\n"
+ " Stdcall,\n"
+ " Async,\n"
+ " };\n"
+ "\n"
+ " pub const FnArg = struct {\n"
+ " is_generic: bool,\n"
+ " is_noalias: bool,\n"
+ " arg_type: type,\n"
+ " };\n"
+ "\n"
+ " pub const Fn = struct {\n"
+ " calling_convention: CallingConvention,\n"
+ " is_generic: bool,\n"
+ " is_var_args: bool,\n"
+ " return_type: type,\n"
+ " async_allocator_type: type,\n"
+ " args: []FnArg,\n"
+ " };\n"
+ "\n"
+ " pub const Promise = struct {\n"
+ " child: type,\n"
+ " };\n"
+ "\n"
+ " pub const Definition = struct {\n"
+ " name: []const u8,\n"
+ " is_pub: bool,\n"
+ " data: Data,\n"
+ "\n"
+ " pub const Data = union(enum) {\n"
+ " Type: type,\n"
+ " Var: type,\n"
+ " Fn: FnDef,\n"
+ "\n"
+ " pub const FnDef = struct {\n"
+ " fn_type: type,\n"
+ " inline_type: Inline,\n"
+ " calling_convention: CallingConvention,\n"
+ " is_var_args: bool,\n"
+ " is_extern: bool,\n"
+ " is_export: bool,\n"
+ " lib_name: ?[]const u8,\n"
+ " return_type: type,\n"
+ " arg_names: [][] const u8,\n"
+ "\n"
+ " pub const Inline = enum {\n"
+ " Auto,\n"
+ " Always,\n"
+ " Never,\n"
+ " };\n"
+ " };\n"
+ " };\n"
+ " };\n"
+ "};\n\n");
+ assert(ContainerLayoutAuto == 0);
+ assert(ContainerLayoutExtern == 1);
+ assert(ContainerLayoutPacked == 2);
+
+ assert(CallingConventionUnspecified == 0);
+ assert(CallingConventionC == 1);
+ assert(CallingConventionCold == 2);
+ assert(CallingConventionNaked == 3);
+ assert(CallingConventionStdcall == 4);
+ assert(CallingConventionAsync == 5);
+
+ assert(FnInlineAuto == 0);
+ assert(FnInlineAlways == 1);
+ assert(FnInlineNever == 2);
+ }
{
buf_appendf(contents,
"pub const FloatMode = enum {\n"
diff --git a/src/ir.cpp b/src/ir.cpp
index 469900bf0742..cffee9bebc78 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -615,6 +615,10 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionOffsetOf *) {
return IrInstructionIdOffsetOf;
}
+static constexpr IrInstructionId ir_instruction_id(IrInstructionTypeInfo *) {
+ return IrInstructionIdTypeInfo;
+}
+
static constexpr IrInstructionId ir_instruction_id(IrInstructionTypeId *) {
return IrInstructionIdTypeId;
}
@@ -2440,6 +2444,16 @@ static IrInstruction *ir_build_offset_of(IrBuilder *irb, Scope *scope, AstNode *
return &instruction->base;
}
+static IrInstruction *ir_build_type_info(IrBuilder *irb, Scope *scope, AstNode *source_node,
+ IrInstruction *type_value) {
+ IrInstructionTypeInfo *instruction = ir_build_instruction(irb, scope, source_node);
+ instruction->type_value = type_value;
+
+ ir_ref_instruction(type_value, irb->current_basic_block);
+
+ return &instruction->base;
+}
+
static IrInstruction *ir_build_type_id(IrBuilder *irb, Scope *scope, AstNode *source_node,
IrInstruction *type_value)
{
@@ -4083,6 +4097,16 @@ static IrInstruction *ir_gen_builtin_fn_call(IrBuilder *irb, Scope *scope, AstNo
return ir_build_load_ptr(irb, scope, node, ptr_instruction);
}
+ case BuiltinFnIdTypeInfo:
+ {
+ AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
+ IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
+ if (arg0_value == irb->codegen->invalid_instruction)
+ return arg0_value;
+
+ IrInstruction *type_info = ir_build_type_info(irb, scope, node, arg0_value);
+ return ir_lval_wrap(irb, scope, type_info, lval);
+ }
case BuiltinFnIdBreakpoint:
return ir_lval_wrap(irb, scope, ir_build_breakpoint(irb, scope, node), lval);
case BuiltinFnIdReturnAddress:
@@ -13386,7 +13410,6 @@ static IrInstruction *ir_analyze_container_member_access_inner(IrAnalyze *ira,
return ira->codegen->invalid_instruction;
}
-
static IrInstruction *ir_analyze_container_field_ptr(IrAnalyze *ira, Buf *field_name,
IrInstruction *source_instr, IrInstruction *container_ptr, TypeTableEntry *container_type)
{
@@ -13448,6 +13471,51 @@ static IrInstruction *ir_analyze_container_field_ptr(IrAnalyze *ira, Buf *field_
} else if (bare_type->id == TypeTableEntryIdUnion) {
TypeUnionField *field = find_union_type_field(bare_type, field_name);
if (field) {
+ if (instr_is_comptime(container_ptr)) {
+ ConstExprValue *ptr_val = ir_resolve_const(ira, container_ptr, UndefBad);
+ if (!ptr_val)
+ return ira->codegen->invalid_instruction;
+
+ if (ptr_val->data.x_ptr.special != ConstPtrSpecialHardCodedAddr) {
+ ConstExprValue *union_val = const_ptr_pointee(ira->codegen, ptr_val);
+ if (type_is_invalid(union_val->type))
+ return ira->codegen->invalid_instruction;
+
+ TypeUnionField *actual_field = find_union_field_by_tag(bare_type, &union_val->data.x_union.tag);
+ if (actual_field == nullptr)
+ zig_unreachable();
+
+ if (field != actual_field) {
+ ir_add_error_node(ira, source_instr->source_node,
+ buf_sprintf("accessing union field '%s' while field '%s' is set", buf_ptr(field_name),
+ buf_ptr(actual_field->name)));
+ return ira->codegen->invalid_instruction;
+ }
+
+ ConstExprValue *payload_val = union_val->data.x_union.payload;
+
+ TypeTableEntry *field_type = field->type_entry;
+ if (field_type->id == TypeTableEntryIdVoid)
+ {
+ assert(payload_val == nullptr);
+ payload_val = create_const_vals(1);
+ payload_val->special = ConstValSpecialStatic;
+ payload_val->type = field_type;
+ }
+
+ TypeTableEntry *ptr_type = get_pointer_to_type_extra(ira->codegen, field_type, is_const, is_volatile,
+ get_abi_alignment(ira->codegen, field_type), 0, 0);
+
+ IrInstruction *result = ir_get_const(ira, source_instr);
+ ConstExprValue *const_val = &result->value;
+ const_val->data.x_ptr.special = ConstPtrSpecialRef;
+ const_val->data.x_ptr.mut = container_ptr->value.data.x_ptr.mut;
+ const_val->data.x_ptr.data.ref.pointee = payload_val;
+ const_val->type = ptr_type;
+ return result;
+ }
+ }
+
IrInstruction *result = ir_build_union_field_ptr(&ira->new_irb, source_instr->scope, source_instr->source_node, container_ptr, field);
result->value.type = get_pointer_to_type_extra(ira->codegen, field->type_entry, is_const, is_volatile,
get_abi_alignment(ira->codegen, field->type_entry), 0, 0);
@@ -15677,6 +15745,895 @@ static TypeTableEntry *ir_analyze_instruction_offset_of(IrAnalyze *ira,
return ira->codegen->builtin_types.entry_num_lit_int;
}
+static void ensure_field_index(TypeTableEntry *type, const char *field_name, size_t index)
+{
+ Buf *field_name_buf;
+
+ assert(type != nullptr && !type_is_invalid(type));
+ // Check for our field by creating a buffer in place then using the comma operator to free it so that we don't
+ // leak memory in debug mode.
+ assert(find_struct_type_field(type, field_name_buf = buf_create_from_str(field_name))->src_index == index &&
+ (buf_deinit(field_name_buf), true));
+}
+
+static TypeTableEntry *ir_type_info_get_type(IrAnalyze *ira, const char *type_name, TypeTableEntry *root = nullptr)
+{
+ static ConstExprValue *type_info_var = nullptr;
+ static TypeTableEntry *type_info_type = nullptr;
+ if (type_info_var == nullptr)
+ {
+ type_info_var = get_builtin_value(ira->codegen, "TypeInfo");
+ assert(type_info_var->type->id == TypeTableEntryIdMetaType);
+
+ ensure_complete_type(ira->codegen, type_info_var->data.x_type);
+ type_info_type = type_info_var->data.x_type;
+ assert(type_info_type->id == TypeTableEntryIdUnion);
+ }
+
+ if (type_name == nullptr && root == nullptr)
+ return type_info_type;
+ else if (type_name == nullptr)
+ return root;
+
+ TypeTableEntry *root_type = (root == nullptr) ? type_info_type : root;
+
+ ScopeDecls *type_info_scope = get_container_scope(root_type);
+ assert(type_info_scope != nullptr);
+
+ Buf field_name = BUF_INIT;
+ buf_init_from_str(&field_name, type_name);
+ auto entry = type_info_scope->decl_table.maybe_get(&field_name);
+ buf_deinit(&field_name);
+ assert(entry != nullptr);
+
+ TldVar *tld = (TldVar *)entry->value;
+ assert(tld->base.id == TldIdVar);
+
+ VariableTableEntry *var = tld->var;
+
+ ensure_complete_type(ira->codegen, var->value->type);
+ assert(var->value->type->id == TypeTableEntryIdMetaType);
+ return var->value->data.x_type;
+}
+
+static void ir_make_type_info_defs(IrAnalyze *ira, ConstExprValue *out_val, ScopeDecls *decls_scope)
+{
+ TypeTableEntry *type_info_definition_type = ir_type_info_get_type(ira, "Definition");
+ ensure_complete_type(ira->codegen, type_info_definition_type);
+ ensure_field_index(type_info_definition_type, "name", 0);
+ ensure_field_index(type_info_definition_type, "is_pub", 1);
+ ensure_field_index(type_info_definition_type, "data", 2);
+
+ TypeTableEntry *type_info_definition_data_type = ir_type_info_get_type(ira, "Data", type_info_definition_type);
+ ensure_complete_type(ira->codegen, type_info_definition_data_type);
+
+ TypeTableEntry *type_info_fn_def_type = ir_type_info_get_type(ira, "FnDef", type_info_definition_data_type);
+ ensure_complete_type(ira->codegen, type_info_fn_def_type);
+
+ TypeTableEntry *type_info_fn_def_inline_type = ir_type_info_get_type(ira, "Inline", type_info_fn_def_type);
+ ensure_complete_type(ira->codegen, type_info_fn_def_inline_type);
+
+ // Loop through our definitions once to figure out how many definitions we will generate info for.
+ auto decl_it = decls_scope->decl_table.entry_iterator();
+ decltype(decls_scope->decl_table)::Entry *curr_entry = nullptr;
+ int definition_count = 0;
+
+ while ((curr_entry = decl_it.next()) != nullptr)
+ {
+ // If the definition is unresolved, force it to be resolved again.
+ if (curr_entry->value->resolution == TldResolutionUnresolved)
+ {
+ resolve_top_level_decl(ira->codegen, curr_entry->value, false, curr_entry->value->source_node);
+ if (curr_entry->value->resolution != TldResolutionOk)
+ {
+ return;
+ }
+ }
+
+ // Skip comptime blocks and test functions.
+ if (curr_entry->value->id != TldIdCompTime)
+ {
+ if (curr_entry->value->id == TldIdFn)
+ {
+ FnTableEntry *fn_entry = ((TldFn *)curr_entry->value)->fn_entry;
+ if (fn_entry->is_test)
+ continue;
+ }
+
+ definition_count += 1;
+ }
+ }
+
+ ConstExprValue *definition_array = create_const_vals(1);
+ definition_array->special = ConstValSpecialStatic;
+ definition_array->type = get_array_type(ira->codegen, type_info_definition_type, definition_count);
+ definition_array->data.x_array.special = ConstArraySpecialNone;
+ definition_array->data.x_array.s_none.parent.id = ConstParentIdNone;
+ definition_array->data.x_array.s_none.elements = create_const_vals(definition_count);
+ init_const_slice(ira->codegen, out_val, definition_array, 0, definition_count, false);
+
+ // Loop through the definitions and generate info.
+ decl_it = decls_scope->decl_table.entry_iterator();
+ curr_entry = nullptr;
+ int definition_index = 0;
+ while ((curr_entry = decl_it.next()) != nullptr)
+ {
+ // Skip comptime blocks and test functions.
+ if (curr_entry->value->id == TldIdCompTime)
+ continue;
+ else if (curr_entry->value->id == TldIdFn)
+ {
+ FnTableEntry *fn_entry = ((TldFn *)curr_entry->value)->fn_entry;
+ if (fn_entry->is_test)
+ continue;
+ }
+
+ ConstExprValue *definition_val = &definition_array->data.x_array.s_none.elements[definition_index];
+
+ definition_val->special = ConstValSpecialStatic;
+ definition_val->type = type_info_definition_type;
+
+ ConstExprValue *inner_fields = create_const_vals(3);
+ ConstExprValue *name = create_const_str_lit(ira->codegen, curr_entry->key);
+ init_const_slice(ira->codegen, &inner_fields[0], name, 0, buf_len(curr_entry->key), true);
+ inner_fields[1].special = ConstValSpecialStatic;
+ inner_fields[1].type = ira->codegen->builtin_types.entry_bool;
+ inner_fields[1].data.x_bool = curr_entry->value->visib_mod == VisibModPub;
+ inner_fields[2].special = ConstValSpecialStatic;
+ inner_fields[2].type = type_info_definition_data_type;
+ inner_fields[2].data.x_union.parent.id = ConstParentIdStruct;
+ inner_fields[2].data.x_union.parent.data.p_struct.struct_val = definition_val;
+ inner_fields[2].data.x_union.parent.data.p_struct.field_index = 1;
+
+ switch (curr_entry->value->id)
+ {
+ case TldIdVar:
+ {
+ VariableTableEntry *var = ((TldVar *)curr_entry->value)->var;
+ ensure_complete_type(ira->codegen, var->value->type);
+ if (var->value->type->id == TypeTableEntryIdMetaType)
+ {
+ // We have a variable of type 'type', so it's actually a type definition.
+ // 0: Data.Type: type
+ bigint_init_unsigned(&inner_fields[2].data.x_union.tag, 0);
+ inner_fields[2].data.x_union.payload = var->value;
+ }
+ else
+ {
+ // We have a variable of another type, so we store the type of the variable.
+ // 1: Data.Var: type
+ bigint_init_unsigned(&inner_fields[2].data.x_union.tag, 1);
+
+ ConstExprValue *payload = create_const_vals(1);
+ payload->type = ira->codegen->builtin_types.entry_type;
+ payload->data.x_type = var->value->type;
+
+ inner_fields[2].data.x_union.payload = payload;
+ }
+
+ break;
+ }
+ case TldIdFn:
+ {
+ // 2: Data.Fn: Data.FnDef
+ bigint_init_unsigned(&inner_fields[2].data.x_union.tag, 2);
+
+ FnTableEntry *fn_entry = ((TldFn *)curr_entry->value)->fn_entry;
+ assert(!fn_entry->is_test);
+
+ analyze_fn_body(ira->codegen, fn_entry);
+ if (fn_entry->anal_state == FnAnalStateInvalid)
+ return;
+
+ AstNodeFnProto *fn_node = (AstNodeFnProto *)(fn_entry->proto_node);
+
+ ConstExprValue *fn_def_val = create_const_vals(1);
+ fn_def_val->special = ConstValSpecialStatic;
+ fn_def_val->type = type_info_fn_def_type;
+ fn_def_val->data.x_struct.parent.id = ConstParentIdUnion;
+ fn_def_val->data.x_struct.parent.data.p_union.union_val = &inner_fields[2];
+
+ ConstExprValue *fn_def_fields = create_const_vals(9);
+ fn_def_val->data.x_struct.fields = fn_def_fields;
+
+ // fn_type: type
+ ensure_field_index(fn_def_val->type, "fn_type", 0);
+ fn_def_fields[0].special = ConstValSpecialStatic;
+ fn_def_fields[0].type = ira->codegen->builtin_types.entry_type;
+ fn_def_fields[0].data.x_type = fn_entry->type_entry;
+ // inline_type: Data.FnDef.Inline
+ ensure_field_index(fn_def_val->type, "inline_type", 1);
+ fn_def_fields[1].special = ConstValSpecialStatic;
+ fn_def_fields[1].type = type_info_fn_def_inline_type;
+ bigint_init_unsigned(&fn_def_fields[1].data.x_enum_tag, fn_entry->fn_inline);
+ // calling_convention: TypeInfo.CallingConvention
+ ensure_field_index(fn_def_val->type, "calling_convention", 2);
+ fn_def_fields[2].special = ConstValSpecialStatic;
+ fn_def_fields[2].type = ir_type_info_get_type(ira, "CallingConvention");
+ bigint_init_unsigned(&fn_def_fields[2].data.x_enum_tag, fn_node->cc);
+ // is_var_args: bool
+ ensure_field_index(fn_def_val->type, "is_var_args", 3);
+ bool is_varargs = fn_node->is_var_args;
+ fn_def_fields[3].special = ConstValSpecialStatic;
+ fn_def_fields[3].type = ira->codegen->builtin_types.entry_bool;
+ fn_def_fields[3].data.x_bool = is_varargs;
+ // is_extern: bool
+ ensure_field_index(fn_def_val->type, "is_extern", 4);
+ fn_def_fields[4].special = ConstValSpecialStatic;
+ fn_def_fields[4].type = ira->codegen->builtin_types.entry_bool;
+ fn_def_fields[4].data.x_bool = fn_node->is_extern;
+ // is_export: bool
+ ensure_field_index(fn_def_val->type, "is_export", 5);
+ fn_def_fields[5].special = ConstValSpecialStatic;
+ fn_def_fields[5].type = ira->codegen->builtin_types.entry_bool;
+ fn_def_fields[5].data.x_bool = fn_node->is_export;
+ // lib_name: ?[]const u8
+ ensure_field_index(fn_def_val->type, "lib_name", 6);
+ fn_def_fields[6].special = ConstValSpecialStatic;
+ fn_def_fields[6].type = get_maybe_type(ira->codegen,
+ get_slice_type(ira->codegen, get_pointer_to_type(ira->codegen,
+ ira->codegen->builtin_types.entry_u8, true)));
+ if (fn_node->is_extern && buf_len(fn_node->lib_name) > 0)
+ {
+ fn_def_fields[6].data.x_maybe = create_const_vals(1);
+ ConstExprValue *lib_name = create_const_str_lit(ira->codegen, fn_node->lib_name);
+ init_const_slice(ira->codegen, fn_def_fields[6].data.x_maybe, lib_name, 0, buf_len(fn_node->lib_name), true);
+ }
+ else
+ fn_def_fields[6].data.x_maybe = nullptr;
+ // return_type: type
+ ensure_field_index(fn_def_val->type, "return_type", 7);
+ fn_def_fields[7].special = ConstValSpecialStatic;
+ fn_def_fields[7].type = ira->codegen->builtin_types.entry_type;
+ if (fn_entry->src_implicit_return_type != nullptr)
+ fn_def_fields[7].data.x_type = fn_entry->src_implicit_return_type;
+ else if (fn_entry->type_entry->data.fn.gen_return_type != nullptr)
+ fn_def_fields[7].data.x_type = fn_entry->type_entry->data.fn.gen_return_type;
+ else
+ fn_def_fields[7].data.x_type = fn_entry->type_entry->data.fn.fn_type_id.return_type;
+ // arg_names: [][] const u8
+ ensure_field_index(fn_def_val->type, "arg_names", 8);
+ size_t fn_arg_count = fn_entry->variable_list.length;
+ ConstExprValue *fn_arg_name_array = create_const_vals(1);
+ fn_arg_name_array->special = ConstValSpecialStatic;
+ fn_arg_name_array->type = get_array_type(ira->codegen, get_slice_type(ira->codegen,
+ get_pointer_to_type(ira->codegen, ira->codegen->builtin_types.entry_u8, true)), fn_arg_count);
+ fn_arg_name_array->data.x_array.special = ConstArraySpecialNone;
+ fn_arg_name_array->data.x_array.s_none.parent.id = ConstParentIdNone;
+ fn_arg_name_array->data.x_array.s_none.elements = create_const_vals(fn_arg_count);
+
+ init_const_slice(ira->codegen, &fn_def_fields[8], fn_arg_name_array, 0, fn_arg_count, false);
+
+ for (size_t fn_arg_index = 0; fn_arg_index < fn_arg_count; fn_arg_index++)
+ {
+ VariableTableEntry *arg_var = fn_entry->variable_list.at(fn_arg_index);
+ ConstExprValue *fn_arg_name_val = &fn_arg_name_array->data.x_array.s_none.elements[fn_arg_index];
+ ConstExprValue *arg_name = create_const_str_lit(ira->codegen, &arg_var->name);
+ init_const_slice(ira->codegen, fn_arg_name_val, arg_name, 0, buf_len(&arg_var->name), true);
+ fn_arg_name_val->data.x_struct.parent.id = ConstParentIdArray;
+ fn_arg_name_val->data.x_struct.parent.data.p_array.array_val = fn_arg_name_array;
+ fn_arg_name_val->data.x_struct.parent.data.p_array.elem_index = fn_arg_index;
+ }
+
+ inner_fields[2].data.x_union.payload = fn_def_val;
+ break;
+ }
+ case TldIdContainer:
+ {
+ TypeTableEntry *type_entry = ((TldContainer *)curr_entry->value)->type_entry;
+ ensure_complete_type(ira->codegen, type_entry);
+ // This is a type.
+ bigint_init_unsigned(&inner_fields[2].data.x_union.tag, 0);
+
+ ConstExprValue *payload = create_const_vals(1);
+ payload->type = ira->codegen->builtin_types.entry_type;
+ payload->data.x_type = type_entry;
+
+ inner_fields[2].data.x_union.payload = payload;
+
+ break;
+ }
+ default:
+ zig_unreachable();
+ }
+
+ definition_val->data.x_struct.fields = inner_fields;
+ definition_index++;
+ }
+
+ assert(definition_index == definition_count);
+}
+
+static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *type_entry)
+{
+ assert(type_entry != nullptr);
+ assert(!type_is_invalid(type_entry));
+
+ ensure_complete_type(ira->codegen, type_entry);
+
+ const auto make_enum_field_val = [ira](ConstExprValue *enum_field_val, TypeEnumField *enum_field,
+ TypeTableEntry *type_info_enum_field_type) {
+ enum_field_val->special = ConstValSpecialStatic;
+ enum_field_val->type = type_info_enum_field_type;
+
+ ConstExprValue *inner_fields = create_const_vals(2);
+ inner_fields[1].special = ConstValSpecialStatic;
+ inner_fields[1].type = ira->codegen->builtin_types.entry_usize;
+
+ ConstExprValue *name = create_const_str_lit(ira->codegen, enum_field->name);
+ init_const_slice(ira->codegen, &inner_fields[0], name, 0, buf_len(enum_field->name), true);
+
+ bigint_init_bigint(&inner_fields[1].data.x_bigint, &enum_field->value);
+
+ enum_field_val->data.x_struct.fields = inner_fields;
+ };
+
+ ConstExprValue *result = nullptr;
+ switch (type_entry->id)
+ {
+ case TypeTableEntryIdInvalid:
+ zig_unreachable();
+ case TypeTableEntryIdMetaType:
+ case TypeTableEntryIdVoid:
+ case TypeTableEntryIdBool:
+ case TypeTableEntryIdUnreachable:
+ case TypeTableEntryIdNumLitFloat:
+ case TypeTableEntryIdNumLitInt:
+ case TypeTableEntryIdUndefLit:
+ case TypeTableEntryIdNullLit:
+ case TypeTableEntryIdNamespace:
+ case TypeTableEntryIdBlock:
+ case TypeTableEntryIdArgTuple:
+ case TypeTableEntryIdOpaque:
+ return nullptr;
+ default:
+ {
+ // Lookup an available value in our cache.
+ auto entry = ira->codegen->type_info_cache.maybe_get(type_entry);
+ if (entry != nullptr)
+ return entry->value;
+
+ // Fallthrough if we don't find one.
+ }
+ case TypeTableEntryIdInt:
+ {
+ result = create_const_vals(1);
+ result->special = ConstValSpecialStatic;
+ result->type = ir_type_info_get_type(ira, "Int");
+
+ ConstExprValue *fields = create_const_vals(2);
+ result->data.x_struct.fields = fields;
+
+ // is_signed: bool
+ ensure_field_index(result->type, "is_signed", 0);
+ fields[0].special = ConstValSpecialStatic;
+ fields[0].type = ira->codegen->builtin_types.entry_bool;
+ fields[0].data.x_bool = type_entry->data.integral.is_signed;
+ // bits: u8
+ ensure_field_index(result->type, "bits", 1);
+ fields[1].special = ConstValSpecialStatic;
+ fields[1].type = ira->codegen->builtin_types.entry_u8;
+ bigint_init_unsigned(&fields[1].data.x_bigint, type_entry->data.integral.bit_count);
+
+ break;
+ }
+ case TypeTableEntryIdFloat:
+ {
+ result = create_const_vals(1);
+ result->special = ConstValSpecialStatic;
+ result->type = ir_type_info_get_type(ira, "Float");
+
+ ConstExprValue *fields = create_const_vals(1);
+ result->data.x_struct.fields = fields;
+
+ // bits: u8
+ ensure_field_index(result->type, "bits", 0);
+ fields[0].special = ConstValSpecialStatic;
+ fields[0].type = ira->codegen->builtin_types.entry_u8;
+ bigint_init_unsigned(&fields->data.x_bigint, type_entry->data.floating.bit_count);
+
+ break;
+ }
+ case TypeTableEntryIdPointer:
+ {
+ result = create_const_vals(1);
+ result->special = ConstValSpecialStatic;
+ result->type = ir_type_info_get_type(ira, "Pointer");
+
+ ConstExprValue *fields = create_const_vals(4);
+ result->data.x_struct.fields = fields;
+
+ // is_const: bool
+ ensure_field_index(result->type, "is_const", 0);
+ fields[0].special = ConstValSpecialStatic;
+ fields[0].type = ira->codegen->builtin_types.entry_bool;
+ fields[0].data.x_bool = type_entry->data.pointer.is_const;
+ // is_volatile: bool
+ ensure_field_index(result->type, "is_volatile", 1);
+ fields[1].special = ConstValSpecialStatic;
+ fields[1].type = ira->codegen->builtin_types.entry_bool;
+ fields[1].data.x_bool = type_entry->data.pointer.is_volatile;
+ // alignment: u32
+ ensure_field_index(result->type, "alignment", 2);
+ fields[2].special = ConstValSpecialStatic;
+ fields[2].type = ira->codegen->builtin_types.entry_u32;
+ bigint_init_unsigned(&fields[2].data.x_bigint, type_entry->data.pointer.alignment);
+ // child: type
+ ensure_field_index(result->type, "child", 3);
+ fields[3].special = ConstValSpecialStatic;
+ fields[3].type = ira->codegen->builtin_types.entry_type;
+ fields[3].data.x_type = type_entry->data.pointer.child_type;
+
+ break;
+ }
+ case TypeTableEntryIdArray:
+ {
+ result = create_const_vals(1);
+ result->special = ConstValSpecialStatic;
+ result->type = ir_type_info_get_type(ira, "Array");
+
+ ConstExprValue *fields = create_const_vals(2);
+ result->data.x_struct.fields = fields;
+
+ // len: usize
+ ensure_field_index(result->type, "len", 0);
+ fields[0].special = ConstValSpecialStatic;
+ fields[0].type = ira->codegen->builtin_types.entry_usize;
+ bigint_init_unsigned(&fields[0].data.x_bigint, type_entry->data.array.len);
+ // child: type
+ ensure_field_index(result->type, "child", 1);
+ fields[1].special = ConstValSpecialStatic;
+ fields[1].type = ira->codegen->builtin_types.entry_type;
+ fields[1].data.x_type = type_entry->data.array.child_type;
+
+ break;
+ }
+ case TypeTableEntryIdMaybe:
+ {
+ result = create_const_vals(1);
+ result->special = ConstValSpecialStatic;
+ result->type = ir_type_info_get_type(ira, "Nullable");
+
+ ConstExprValue *fields = create_const_vals(1);
+ result->data.x_struct.fields = fields;
+
+ // child: type
+ ensure_field_index(result->type, "child", 0);
+ fields[0].special = ConstValSpecialStatic;
+ fields[0].type = ira->codegen->builtin_types.entry_type;
+ fields[0].data.x_type = type_entry->data.maybe.child_type;
+
+ break;
+ }
+ case TypeTableEntryIdPromise:
+ {
+ result = create_const_vals(1);
+ result->special = ConstValSpecialStatic;
+ result->type = ir_type_info_get_type(ira, "Promise");
+
+ ConstExprValue *fields = create_const_vals(1);
+ result->data.x_struct.fields = fields;
+
+ // @TODO ?type instead of using @typeOf(undefined) when we have no type.
+ // child: type
+ ensure_field_index(result->type, "child", 0);
+ fields[0].special = ConstValSpecialStatic;
+ fields[0].type = ira->codegen->builtin_types.entry_type;
+
+ if (type_entry->data.promise.result_type == nullptr)
+ fields[0].data.x_type = ira->codegen->builtin_types.entry_undef;
+ else
+ fields[0].data.x_type = type_entry->data.promise.result_type;
+
+ break;
+ }
+ case TypeTableEntryIdEnum:
+ {
+ result = create_const_vals(1);
+ result->special = ConstValSpecialStatic;
+ result->type = ir_type_info_get_type(ira, "Enum");
+
+ ConstExprValue *fields = create_const_vals(4);
+ result->data.x_struct.fields = fields;
+
+ // layout: ContainerLayout
+ ensure_field_index(result->type, "layout", 0);
+ fields[0].special = ConstValSpecialStatic;
+ fields[0].type = ir_type_info_get_type(ira, "ContainerLayout");
+ bigint_init_unsigned(&fields[0].data.x_enum_tag, type_entry->data.enumeration.layout);
+ // tag_type: type
+ ensure_field_index(result->type, "tag_type", 1);
+ fields[1].special = ConstValSpecialStatic;
+ fields[1].type = ira->codegen->builtin_types.entry_type;
+ fields[1].data.x_type = type_entry->data.enumeration.tag_int_type;
+ // fields: []TypeInfo.EnumField
+ ensure_field_index(result->type, "fields", 2);
+
+ TypeTableEntry *type_info_enum_field_type = ir_type_info_get_type(ira, "EnumField");
+ uint32_t enum_field_count = type_entry->data.enumeration.src_field_count;
+
+ ConstExprValue *enum_field_array = create_const_vals(1);
+ enum_field_array->special = ConstValSpecialStatic;
+ enum_field_array->type = get_array_type(ira->codegen, type_info_enum_field_type, enum_field_count);
+ enum_field_array->data.x_array.special = ConstArraySpecialNone;
+ enum_field_array->data.x_array.s_none.parent.id = ConstParentIdNone;
+ enum_field_array->data.x_array.s_none.elements = create_const_vals(enum_field_count);
+
+ init_const_slice(ira->codegen, &fields[2], enum_field_array, 0, enum_field_count, false);
+
+ for (uint32_t enum_field_index = 0; enum_field_index < enum_field_count; enum_field_index++)
+ {
+ TypeEnumField *enum_field = &type_entry->data.enumeration.fields[enum_field_index];
+ ConstExprValue *enum_field_val = &enum_field_array->data.x_array.s_none.elements[enum_field_index];
+ make_enum_field_val(enum_field_val, enum_field, type_info_enum_field_type);
+ enum_field_val->data.x_struct.parent.id = ConstParentIdArray;
+ enum_field_val->data.x_struct.parent.data.p_array.array_val = enum_field_array;
+ enum_field_val->data.x_struct.parent.data.p_array.elem_index = enum_field_index;
+ }
+ // defs: []TypeInfo.Definition
+ ensure_field_index(result->type, "defs", 3);
+ ir_make_type_info_defs(ira, &fields[3], type_entry->data.enumeration.decls_scope);
+
+ break;
+ }
+ case TypeTableEntryIdErrorSet:
+ {
+ result = create_const_vals(1);
+ result->special = ConstValSpecialStatic;
+ result->type = ir_type_info_get_type(ira, "ErrorSet");
+
+ ConstExprValue *fields = create_const_vals(1);
+ result->data.x_struct.fields = fields;
+
+ // errors: []TypeInfo.Error
+ ensure_field_index(result->type, "errors", 0);
+
+ TypeTableEntry *type_info_error_type = ir_type_info_get_type(ira, "Error");
+ uint32_t error_count = type_entry->data.error_set.err_count;
+ ConstExprValue *error_array = create_const_vals(1);
+ error_array->special = ConstValSpecialStatic;
+ error_array->type = get_array_type(ira->codegen, type_info_error_type, error_count);
+ error_array->data.x_array.special = ConstArraySpecialNone;
+ error_array->data.x_array.s_none.parent.id = ConstParentIdNone;
+ error_array->data.x_array.s_none.elements = create_const_vals(error_count);
+
+ init_const_slice(ira->codegen, &fields[0], error_array, 0, error_count, false);
+ for (uint32_t error_index = 0; error_index < error_count; error_index++)
+ {
+ ErrorTableEntry *error = type_entry->data.error_set.errors[error_index];
+ ConstExprValue *error_val = &error_array->data.x_array.s_none.elements[error_index];
+
+ error_val->special = ConstValSpecialStatic;
+ error_val->type = type_info_error_type;
+
+ ConstExprValue *inner_fields = create_const_vals(2);
+ inner_fields[1].special = ConstValSpecialStatic;
+ inner_fields[1].type = ira->codegen->builtin_types.entry_usize;
+
+ ConstExprValue *name = nullptr;
+ if (error->cached_error_name_val != nullptr)
+ name = error->cached_error_name_val;
+ if (name == nullptr)
+ name = create_const_str_lit(ira->codegen, &error->name);
+ init_const_slice(ira->codegen, &inner_fields[0], name, 0, buf_len(&error->name), true);
+ bigint_init_unsigned(&inner_fields[1].data.x_bigint, error->value);
+
+ error_val->data.x_struct.fields = inner_fields;
+ error_val->data.x_struct.parent.id = ConstParentIdArray;
+ error_val->data.x_struct.parent.data.p_array.array_val = error_array;
+ error_val->data.x_struct.parent.data.p_array.elem_index = error_index;
+ }
+
+ break;
+ }
+ case TypeTableEntryIdErrorUnion:
+ {
+ result = create_const_vals(1);
+ result->special = ConstValSpecialStatic;
+ result->type = ir_type_info_get_type(ira, "ErrorUnion");
+
+ ConstExprValue *fields = create_const_vals(2);
+ result->data.x_struct.fields = fields;
+
+ // error_set: type
+ ensure_field_index(result->type, "error_set", 0);
+ fields[0].special = ConstValSpecialStatic;
+ fields[0].type = ira->codegen->builtin_types.entry_type;
+ fields[0].data.x_type = type_entry->data.error_union.err_set_type;
+
+ // payload: type
+ ensure_field_index(result->type, "payload", 1);
+ fields[1].special = ConstValSpecialStatic;
+ fields[1].type = ira->codegen->builtin_types.entry_type;
+ fields[1].data.x_type = type_entry->data.error_union.payload_type;
+
+ break;
+ }
+ case TypeTableEntryIdUnion:
+ {
+ result = create_const_vals(1);
+ result->special = ConstValSpecialStatic;
+ result->type = ir_type_info_get_type(ira, "Union");
+
+ ConstExprValue *fields = create_const_vals(4);
+ result->data.x_struct.fields = fields;
+
+ // layout: ContainerLayout
+ ensure_field_index(result->type, "layout", 0);
+ fields[0].special = ConstValSpecialStatic;
+ fields[0].type = ir_type_info_get_type(ira, "ContainerLayout");
+ bigint_init_unsigned(&fields[0].data.x_enum_tag, type_entry->data.unionation.layout);
+ // tag_type: type
+ ensure_field_index(result->type, "tag_type", 1);
+ fields[1].special = ConstValSpecialStatic;
+ fields[1].type = ira->codegen->builtin_types.entry_type;
+ // @TODO ?type instead of using @typeOf(undefined) when we have no type.
+ AstNode *union_decl_node = type_entry->data.unionation.decl_node;
+ if (union_decl_node->data.container_decl.auto_enum ||
+ union_decl_node->data.container_decl.init_arg_expr != nullptr)
+ {
+ fields[1].data.x_type = type_entry->data.unionation.tag_type;
+ }
+ else
+ fields[1].data.x_type = ira->codegen->builtin_types.entry_undef;
+ // fields: []TypeInfo.UnionField
+ ensure_field_index(result->type, "fields", 2);
+
+ TypeTableEntry *type_info_union_field_type = ir_type_info_get_type(ira, "UnionField");
+ uint32_t union_field_count = type_entry->data.unionation.src_field_count;
+
+ ConstExprValue *union_field_array = create_const_vals(1);
+ union_field_array->special = ConstValSpecialStatic;
+ union_field_array->type = get_array_type(ira->codegen, type_info_union_field_type, union_field_count);
+ union_field_array->data.x_array.special = ConstArraySpecialNone;
+ union_field_array->data.x_array.s_none.parent.id = ConstParentIdNone;
+ union_field_array->data.x_array.s_none.elements = create_const_vals(union_field_count);
+
+ init_const_slice(ira->codegen, &fields[2], union_field_array, 0, union_field_count, false);
+
+ TypeTableEntry *type_info_enum_field_type = ir_type_info_get_type(ira, "EnumField");
+
+ for (uint32_t union_field_index = 0; union_field_index < union_field_count; union_field_index++)
+ {
+ TypeUnionField *union_field = &type_entry->data.unionation.fields[union_field_index];
+ ConstExprValue *union_field_val = &union_field_array->data.x_array.s_none.elements[union_field_index];
+
+ union_field_val->special = ConstValSpecialStatic;
+ union_field_val->type = type_info_union_field_type;
+
+ ConstExprValue *inner_fields = create_const_vals(3);
+ inner_fields[1].special = ConstValSpecialStatic;
+ inner_fields[1].type = get_maybe_type(ira->codegen, type_info_enum_field_type);
+
+ if (fields[1].data.x_type == ira->codegen->builtin_types.entry_undef)
+ inner_fields[1].data.x_maybe = nullptr;
+ else
+ {
+ inner_fields[1].data.x_maybe = create_const_vals(1);
+ make_enum_field_val(inner_fields[1].data.x_maybe, union_field->enum_field, type_info_enum_field_type);
+ }
+
+ inner_fields[2].special = ConstValSpecialStatic;
+ inner_fields[2].type = ira->codegen->builtin_types.entry_type;
+ inner_fields[2].data.x_type = union_field->type_entry;
+
+ ConstExprValue *name = create_const_str_lit(ira->codegen, union_field->name);
+ init_const_slice(ira->codegen, &inner_fields[0], name, 0, buf_len(union_field->name), true);
+
+ union_field_val->data.x_struct.fields = inner_fields;
+ union_field_val->data.x_struct.parent.id = ConstParentIdArray;
+ union_field_val->data.x_struct.parent.data.p_array.array_val = union_field_array;
+ union_field_val->data.x_struct.parent.data.p_array.elem_index = union_field_index;
+ }
+ // defs: []TypeInfo.Definition
+ ensure_field_index(result->type, "defs", 3);
+ ir_make_type_info_defs(ira, &fields[3], type_entry->data.unionation.decls_scope);
+
+ break;
+ }
+ case TypeTableEntryIdStruct:
+ {
+ result = create_const_vals(1);
+ result->special = ConstValSpecialStatic;
+ result->type = ir_type_info_get_type(ira, "Struct");
+
+ ConstExprValue *fields = create_const_vals(3);
+ result->data.x_struct.fields = fields;
+
+ // layout: ContainerLayout
+ ensure_field_index(result->type, "layout", 0);
+ fields[0].special = ConstValSpecialStatic;
+ fields[0].type = ir_type_info_get_type(ira, "ContainerLayout");
+ bigint_init_unsigned(&fields[0].data.x_enum_tag, type_entry->data.structure.layout);
+ // fields: []TypeInfo.StructField
+ ensure_field_index(result->type, "fields", 1);
+
+ TypeTableEntry *type_info_struct_field_type = ir_type_info_get_type(ira, "StructField");
+ uint32_t struct_field_count = type_entry->data.structure.src_field_count;
+
+ ConstExprValue *struct_field_array = create_const_vals(1);
+ struct_field_array->special = ConstValSpecialStatic;
+ struct_field_array->type = get_array_type(ira->codegen, type_info_struct_field_type, struct_field_count);
+ struct_field_array->data.x_array.special = ConstArraySpecialNone;
+ struct_field_array->data.x_array.s_none.parent.id = ConstParentIdNone;
+ struct_field_array->data.x_array.s_none.elements = create_const_vals(struct_field_count);
+
+ init_const_slice(ira->codegen, &fields[1], struct_field_array, 0, struct_field_count, false);
+
+ for (uint32_t struct_field_index = 0; struct_field_index < struct_field_count; struct_field_index++)
+ {
+ TypeStructField *struct_field = &type_entry->data.structure.fields[struct_field_index];
+ ConstExprValue *struct_field_val = &struct_field_array->data.x_array.s_none.elements[struct_field_index];
+
+ struct_field_val->special = ConstValSpecialStatic;
+ struct_field_val->type = type_info_struct_field_type;
+
+ ConstExprValue *inner_fields = create_const_vals(3);
+ inner_fields[1].special = ConstValSpecialStatic;
+ inner_fields[1].type = get_maybe_type(ira->codegen, ira->codegen->builtin_types.entry_usize);
+
+ if (!type_has_bits(struct_field->type_entry))
+ inner_fields[1].data.x_maybe = nullptr;
+ else
+ {
+ size_t byte_offset = LLVMOffsetOfElement(ira->codegen->target_data_ref, type_entry->type_ref, struct_field->gen_index);
+ inner_fields[1].data.x_maybe = create_const_vals(1);
+ inner_fields[1].data.x_maybe->type = ira->codegen->builtin_types.entry_usize;
+ bigint_init_unsigned(&inner_fields[1].data.x_maybe->data.x_bigint, byte_offset);
+ }
+
+ inner_fields[2].special = ConstValSpecialStatic;
+ inner_fields[2].type = ira->codegen->builtin_types.entry_type;
+ inner_fields[2].data.x_type = struct_field->type_entry;
+
+ ConstExprValue *name = create_const_str_lit(ira->codegen, struct_field->name);
+ init_const_slice(ira->codegen, &inner_fields[0], name, 0, buf_len(struct_field->name), true);
+
+ struct_field_val->data.x_struct.fields = inner_fields;
+ struct_field_val->data.x_struct.parent.id = ConstParentIdArray;
+ struct_field_val->data.x_struct.parent.data.p_array.array_val = struct_field_array;
+ struct_field_val->data.x_struct.parent.data.p_array.elem_index = struct_field_index;
+ }
+ // defs: []TypeInfo.Definition
+ ensure_field_index(result->type, "defs", 2);
+ ir_make_type_info_defs(ira, &fields[2], type_entry->data.structure.decls_scope);
+
+ break;
+ }
+ case TypeTableEntryIdFn:
+ {
+ result = create_const_vals(1);
+ result->special = ConstValSpecialStatic;
+ result->type = ir_type_info_get_type(ira, "Fn");
+
+ ConstExprValue *fields = create_const_vals(6);
+ result->data.x_struct.fields = fields;
+
+ // @TODO Fix type = undefined with ?type
+
+ // calling_convention: TypeInfo.CallingConvention
+ ensure_field_index(result->type, "calling_convention", 0);
+ fields[0].special = ConstValSpecialStatic;
+ fields[0].type = ir_type_info_get_type(ira, "CallingConvention");
+ bigint_init_unsigned(&fields[0].data.x_enum_tag, type_entry->data.fn.fn_type_id.cc);
+ // is_generic: bool
+ ensure_field_index(result->type, "is_generic", 1);
+ bool is_generic = type_entry->data.fn.is_generic;
+ fields[1].special = ConstValSpecialStatic;
+ fields[1].type = ira->codegen->builtin_types.entry_bool;
+ fields[1].data.x_bool = is_generic;
+ // is_varargs: bool
+ ensure_field_index(result->type, "is_var_args", 2);
+ bool is_varargs = type_entry->data.fn.fn_type_id.is_var_args;
+ fields[2].special = ConstValSpecialStatic;
+ fields[2].type = ira->codegen->builtin_types.entry_bool;
+ fields[2].data.x_bool = type_entry->data.fn.fn_type_id.is_var_args;
+ // return_type: type
+ ensure_field_index(result->type, "return_type", 3);
+ fields[3].special = ConstValSpecialStatic;
+ fields[3].type = ira->codegen->builtin_types.entry_type;
+ if (type_entry->data.fn.fn_type_id.return_type == nullptr)
+ fields[3].data.x_type = ira->codegen->builtin_types.entry_undef;
+ else
+ fields[3].data.x_type = type_entry->data.fn.fn_type_id.return_type;
+ // async_allocator_type: type
+ ensure_field_index(result->type, "async_allocator_type", 4);
+ fields[4].special = ConstValSpecialStatic;
+ fields[4].type = ira->codegen->builtin_types.entry_type;
+ if (type_entry->data.fn.fn_type_id.async_allocator_type == nullptr)
+ fields[4].data.x_type = ira->codegen->builtin_types.entry_undef;
+ else
+ fields[4].data.x_type = type_entry->data.fn.fn_type_id.async_allocator_type;
+ // args: []TypeInfo.FnArg
+ TypeTableEntry *type_info_fn_arg_type = ir_type_info_get_type(ira, "FnArg");
+ size_t fn_arg_count = type_entry->data.fn.fn_type_id.param_count -
+ (is_varargs && type_entry->data.fn.fn_type_id.cc != CallingConventionC);
+
+ ConstExprValue *fn_arg_array = create_const_vals(1);
+ fn_arg_array->special = ConstValSpecialStatic;
+ fn_arg_array->type = get_array_type(ira->codegen, type_info_fn_arg_type, fn_arg_count);
+ fn_arg_array->data.x_array.special = ConstArraySpecialNone;
+ fn_arg_array->data.x_array.s_none.parent.id = ConstParentIdNone;
+ fn_arg_array->data.x_array.s_none.elements = create_const_vals(fn_arg_count);
+
+ init_const_slice(ira->codegen, &fields[5], fn_arg_array, 0, fn_arg_count, false);
+
+ for (size_t fn_arg_index = 0; fn_arg_index < fn_arg_count; fn_arg_index++)
+ {
+ FnTypeParamInfo *fn_param_info = &type_entry->data.fn.fn_type_id.param_info[fn_arg_index];
+ ConstExprValue *fn_arg_val = &fn_arg_array->data.x_array.s_none.elements[fn_arg_index];
+
+ fn_arg_val->special = ConstValSpecialStatic;
+ fn_arg_val->type = type_info_fn_arg_type;
+
+ bool arg_is_generic = fn_param_info->type == nullptr;
+ if (arg_is_generic) assert(is_generic);
+
+ ConstExprValue *inner_fields = create_const_vals(3);
+ inner_fields[0].special = ConstValSpecialStatic;
+ inner_fields[0].type = ira->codegen->builtin_types.entry_bool;
+ inner_fields[0].data.x_bool = arg_is_generic;
+ inner_fields[1].special = ConstValSpecialStatic;
+ inner_fields[1].type = ira->codegen->builtin_types.entry_bool;
+ inner_fields[1].data.x_bool = fn_param_info->is_noalias;
+ inner_fields[2].special = ConstValSpecialStatic;
+ inner_fields[2].type = ira->codegen->builtin_types.entry_type;
+
+ if (arg_is_generic)
+ inner_fields[2].data.x_type = ira->codegen->builtin_types.entry_undef;
+ else
+ inner_fields[2].data.x_type = fn_param_info->type;
+
+ fn_arg_val->data.x_struct.fields = inner_fields;
+ fn_arg_val->data.x_struct.parent.id = ConstParentIdArray;
+ fn_arg_val->data.x_struct.parent.data.p_array.array_val = fn_arg_array;
+ fn_arg_val->data.x_struct.parent.data.p_array.elem_index = fn_arg_index;
+ }
+
+ break;
+ }
+ case TypeTableEntryIdBoundFn:
+ {
+ TypeTableEntry *fn_type = type_entry->data.bound_fn.fn_type;
+ assert(fn_type->id == TypeTableEntryIdFn);
+ result = ir_make_type_info_value(ira, fn_type);
+
+ break;
+ }
+ }
+
+ assert(result != nullptr);
+ ira->codegen->type_info_cache.put(type_entry, result);
+ return result;
+}
+
+static TypeTableEntry *ir_analyze_instruction_type_info(IrAnalyze *ira,
+ IrInstructionTypeInfo *instruction)
+{
+ IrInstruction *type_value = instruction->type_value->other;
+ TypeTableEntry *type_entry = ir_resolve_type(ira, type_value);
+ if (type_is_invalid(type_entry))
+ return ira->codegen->builtin_types.entry_invalid;
+
+ TypeTableEntry *result_type = ir_type_info_get_type(ira, nullptr);
+
+ ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
+ out_val->type = result_type;
+ bigint_init_unsigned(&out_val->data.x_union.tag, type_id_index(type_entry->id));
+
+ ConstExprValue *payload = ir_make_type_info_value(ira, type_entry);
+ out_val->data.x_union.payload = payload;
+
+ if (payload != nullptr)
+ {
+ assert(payload->type->id == TypeTableEntryIdStruct);
+ payload->data.x_struct.parent.id = ConstParentIdUnion;
+ payload->data.x_struct.parent.data.p_union.union_val = out_val;
+ }
+
+ return result_type;
+}
+
static TypeTableEntry *ir_analyze_instruction_type_id(IrAnalyze *ira,
IrInstructionTypeId *instruction)
{
@@ -18578,6 +19535,8 @@ static TypeTableEntry *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstructi
return ir_analyze_instruction_field_parent_ptr(ira, (IrInstructionFieldParentPtr *)instruction);
case IrInstructionIdOffsetOf:
return ir_analyze_instruction_offset_of(ira, (IrInstructionOffsetOf *)instruction);
+ case IrInstructionIdTypeInfo:
+ return ir_analyze_instruction_type_info(ira, (IrInstructionTypeInfo *) instruction);
case IrInstructionIdTypeId:
return ir_analyze_instruction_type_id(ira, (IrInstructionTypeId *)instruction);
case IrInstructionIdSetEvalBranchQuota:
@@ -18844,6 +19803,7 @@ bool ir_has_side_effects(IrInstruction *instruction) {
case IrInstructionIdTagName:
case IrInstructionIdFieldParentPtr:
case IrInstructionIdOffsetOf:
+ case IrInstructionIdTypeInfo:
case IrInstructionIdTypeId:
case IrInstructionIdAlignCast:
case IrInstructionIdOpaqueType:
diff --git a/src/ir_print.cpp b/src/ir_print.cpp
index a77ae244d43f..9678120f1dcd 100644
--- a/src/ir_print.cpp
+++ b/src/ir_print.cpp
@@ -966,6 +966,12 @@ static void ir_print_offset_of(IrPrint *irp, IrInstructionOffsetOf *instruction)
fprintf(irp->f, ")");
}
+static void ir_print_type_info(IrPrint *irp, IrInstructionTypeInfo *instruction) {
+ fprintf(irp->f, "@typeInfo(");
+ ir_print_other_instruction(irp, instruction->type_value);
+ fprintf(irp->f, ")");
+}
+
static void ir_print_type_id(IrPrint *irp, IrInstructionTypeId *instruction) {
fprintf(irp->f, "@typeId(");
ir_print_other_instruction(irp, instruction->type_value);
@@ -1536,6 +1542,9 @@ static void ir_print_instruction(IrPrint *irp, IrInstruction *instruction) {
case IrInstructionIdOffsetOf:
ir_print_offset_of(irp, (IrInstructionOffsetOf *)instruction);
break;
+ case IrInstructionIdTypeInfo:
+ ir_print_type_info(irp, (IrInstructionTypeInfo *)instruction);
+ break;
case IrInstructionIdTypeId:
ir_print_type_id(irp, (IrInstructionTypeId *)instruction);
break;
diff --git a/test/behavior.zig b/test/behavior.zig
index 2c10c6d71bfd..3efd65e5dd0d 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -36,6 +36,7 @@ comptime {
_ = @import("cases/pub_enum/index.zig");
_ = @import("cases/ref_var_in_if_after_if_2nd_switch_prong.zig");
_ = @import("cases/reflection.zig");
+ _ = @import("cases/type_info.zig");
_ = @import("cases/sizeof_and_typeof.zig");
_ = @import("cases/slice.zig");
_ = @import("cases/struct.zig");
diff --git a/test/cases/type_info.zig b/test/cases/type_info.zig
new file mode 100644
index 000000000000..c9b15157e81f
--- /dev/null
+++ b/test/cases/type_info.zig
@@ -0,0 +1,181 @@
+const assert = @import("std").debug.assert;
+const mem = @import("std").mem;
+const TypeInfo = @import("builtin").TypeInfo;
+const TypeId = @import("builtin").TypeId;
+
+test "type info: tag type, void info" {
+ comptime {
+ assert(@TagType(TypeInfo) == TypeId);
+ const void_info = @typeInfo(void);
+ assert(TypeId(void_info) == TypeId.Void);
+ assert(void_info.Void == {});
+ }
+}
+
+test "type info: integer, floating point type info" {
+ comptime {
+ const u8_info = @typeInfo(u8);
+ assert(TypeId(u8_info) == TypeId.Int);
+ assert(!u8_info.Int.is_signed);
+ assert(u8_info.Int.bits == 8);
+
+ const f64_info = @typeInfo(f64);
+ assert(TypeId(f64_info) == TypeId.Float);
+ assert(f64_info.Float.bits == 64);
+ }
+}
+
+test "type info: pointer, array and nullable type info" {
+ comptime {
+ const u32_ptr_info = @typeInfo(&u32);
+ assert(TypeId(u32_ptr_info) == TypeId.Pointer);
+ assert(u32_ptr_info.Pointer.is_const == false);
+ assert(u32_ptr_info.Pointer.is_volatile == false);
+ assert(u32_ptr_info.Pointer.alignment == 4);
+ assert(u32_ptr_info.Pointer.child == u32);
+
+ const arr_info = @typeInfo([42]bool);
+ assert(TypeId(arr_info) == TypeId.Array);
+ assert(arr_info.Array.len == 42);
+ assert(arr_info.Array.child == bool);
+
+ const null_info = @typeInfo(?void);
+ assert(TypeId(null_info) == TypeId.Nullable);
+ assert(null_info.Nullable.child == void);
+ }
+}
+
+test "type info: promise info" {
+ comptime {
+ const null_promise_info = @typeInfo(promise);
+ assert(TypeId(null_promise_info) == TypeId.Promise);
+ assert(null_promise_info.Promise.child == @typeOf(undefined));
+
+ const promise_info = @typeInfo(promise->usize);
+ assert(TypeId(promise_info) == TypeId.Promise);
+ assert(promise_info.Promise.child == usize);
+ }
+
+}
+
+test "type info: error set, error union info" {
+ comptime {
+ const TestErrorSet = error {
+ First,
+ Second,
+ Third,
+ };
+
+ const error_set_info = @typeInfo(TestErrorSet);
+ assert(TypeId(error_set_info) == TypeId.ErrorSet);
+ assert(error_set_info.ErrorSet.errors.len == 3);
+ assert(mem.eql(u8, error_set_info.ErrorSet.errors[0].name, "First"));
+ assert(error_set_info.ErrorSet.errors[2].value == usize(TestErrorSet.Third));
+
+ const error_union_info = @typeInfo(TestErrorSet!usize);
+ assert(TypeId(error_union_info) == TypeId.ErrorUnion);
+ assert(error_union_info.ErrorUnion.error_set == TestErrorSet);
+ assert(error_union_info.ErrorUnion.payload == usize);
+ }
+}
+
+test "type info: enum info" {
+ comptime {
+ const Os = @import("builtin").Os;
+
+ const os_info = @typeInfo(Os);
+ assert(TypeId(os_info) == TypeId.Enum);
+ assert(os_info.Enum.layout == TypeInfo.ContainerLayout.Auto);
+ assert(os_info.Enum.fields.len == 32);
+ assert(mem.eql(u8, os_info.Enum.fields[1].name, "ananas"));
+ assert(os_info.Enum.fields[10].value == 10);
+ assert(os_info.Enum.tag_type == u5);
+ assert(os_info.Enum.defs.len == 0);
+ }
+}
+
+test "type info: union info" {
+ comptime {
+ const typeinfo_info = @typeInfo(TypeInfo);
+ assert(TypeId(typeinfo_info) == TypeId.Union);
+ assert(typeinfo_info.Union.layout == TypeInfo.ContainerLayout.Auto);
+ assert(typeinfo_info.Union.tag_type == TypeId);
+ assert(typeinfo_info.Union.fields.len == 25);
+ assert(typeinfo_info.Union.fields[4].enum_field != null);
+ assert((??typeinfo_info.Union.fields[4].enum_field).value == 4);
+ assert(typeinfo_info.Union.fields[4].field_type == @typeOf(@typeInfo(u8).Int));
+ assert(typeinfo_info.Union.defs.len == 20);
+
+ const TestNoTagUnion = union {
+ Foo: void,
+ Bar: u32,
+ };
+
+ const notag_union_info = @typeInfo(TestNoTagUnion);
+ assert(TypeId(notag_union_info) == TypeId.Union);
+ assert(notag_union_info.Union.tag_type == @typeOf(undefined));
+ assert(notag_union_info.Union.layout == TypeInfo.ContainerLayout.Auto);
+ assert(notag_union_info.Union.fields.len == 2);
+ assert(notag_union_info.Union.fields[0].enum_field == null);
+ assert(notag_union_info.Union.fields[1].field_type == u32);
+
+ const TestExternUnion = extern union {
+ foo: &c_void,
+ };
+
+ const extern_union_info = @typeInfo(TestExternUnion);
+ assert(extern_union_info.Union.layout == TypeInfo.ContainerLayout.Extern);
+ assert(extern_union_info.Union.tag_type == @typeOf(undefined));
+ assert(extern_union_info.Union.fields[0].enum_field == null);
+ assert(extern_union_info.Union.fields[0].field_type == &c_void);
+ }
+}
+
+test "type info: struct info" {
+ comptime {
+ const struct_info = @typeInfo(TestStruct);
+ assert(TypeId(struct_info) == TypeId.Struct);
+ assert(struct_info.Struct.layout == TypeInfo.ContainerLayout.Packed);
+ assert(struct_info.Struct.fields.len == 3);
+ assert(struct_info.Struct.fields[1].offset == null);
+ assert(struct_info.Struct.fields[2].field_type == &TestStruct);
+ assert(struct_info.Struct.defs.len == 2);
+ assert(struct_info.Struct.defs[0].is_pub);
+ assert(!struct_info.Struct.defs[0].data.Fn.is_extern);
+ assert(struct_info.Struct.defs[0].data.Fn.lib_name == null);
+ assert(struct_info.Struct.defs[0].data.Fn.return_type == void);
+ assert(struct_info.Struct.defs[0].data.Fn.fn_type == fn(&const TestStruct)void);
+ }
+}
+
+const TestStruct = packed struct {
+ const Self = this;
+
+ fieldA: usize,
+ fieldB: void,
+ fieldC: &Self,
+
+ pub fn foo(self: &const Self) void {}
+};
+
+test "type info: function type info" {
+ comptime {
+ const fn_info = @typeInfo(@typeOf(foo));
+ assert(TypeId(fn_info) == TypeId.Fn);
+ assert(fn_info.Fn.calling_convention == TypeInfo.CallingConvention.Unspecified);
+ assert(fn_info.Fn.is_generic);
+ assert(fn_info.Fn.args.len == 2);
+ assert(fn_info.Fn.is_var_args);
+ assert(fn_info.Fn.return_type == @typeOf(undefined));
+ assert(fn_info.Fn.async_allocator_type == @typeOf(undefined));
+
+ const test_instance: TestStruct = undefined;
+ const bound_fn_info = @typeInfo(@typeOf(test_instance.foo));
+ assert(TypeId(bound_fn_info) == TypeId.BoundFn);
+ assert(bound_fn_info.BoundFn.args[0].arg_type == &const TestStruct);
+ }
+}
+
+fn foo(comptime a: usize, b: bool, args: ...) usize {
+ return 0;
+}
diff --git a/test/cases/union.zig b/test/cases/union.zig
index dc2a7c3414e4..e7d9c23d77c4 100644
--- a/test/cases/union.zig
+++ b/test/cases/union.zig
@@ -45,6 +45,16 @@ test "basic unions" {
assert(foo.float == 12.34);
}
+test "comptime union field access" {
+ comptime {
+ var foo = Foo { .int = 0 };
+ assert(foo.int == 0);
+
+ foo = Foo { .float = 42.42 };
+ assert(foo.float == 42.42);
+ }
+}
+
test "init union with runtime value" {
var foo: Foo = undefined;
diff --git a/test/compile_errors.zig b/test/compile_errors.zig
index 52e063eb39dc..300f27cb6a7e 100644
--- a/test/compile_errors.zig
+++ b/test/compile_errors.zig
@@ -3210,6 +3210,18 @@ pub fn addCases(cases: &tests.CompileErrorContext) void {
,
".tmp_source.zig:5:42: error: zero-bit field 'val' in struct 'Empty' has no offset");
+ cases.add("invalid union field access in comptime",
+ \\const Foo = union {
+ \\ Bar: u8,
+ \\ Baz: void,
+ \\};
+ \\comptime {
+ \\ var foo = Foo {.Baz = {}};
+ \\ const bar_val = foo.Bar;
+ \\}
+ ,
+ ".tmp_source.zig:7:24: error: accessing union field 'Bar' while field 'Baz' is set");
+
cases.add("getting return type of generic function",
\\fn generic(a: var) void {}
\\comptime {
@@ -3225,5 +3237,4 @@ pub fn addCases(cases: &tests.CompileErrorContext) void {
\\}
,
".tmp_source.zig:3:36: error: @ArgType could not resolve the type of arg 0 because 'fn(var)var' is generic");
-
}