| ... | @@ -2822,6 +2822,17 @@ fn interpretStdLangType( | ... | @@ -2822,6 +2822,17 @@ fn interpretStdLangType( |
| 2822 | }; | 2822 | }; |
| 2823 | } | 2823 | } |
| 2824 | | 2824 | |
| | 2825 | fn uninterpretStdLangType( |
| | 2826 | sema: *Sema, |
| | 2827 | val: anytype, |
| | 2828 | ty: Type, |
| | 2829 | ) !Value { |
| | 2830 | return Value.uninterpret(val, ty, sema.pt) catch |err| switch (err) { |
| | 2831 | error.OutOfMemory => |e| return e, |
| | 2832 | error.TypeMismatch => @panic("std.lang is corrupt"), |
| | 2833 | }; |
| | 2834 | } |
| | 2835 | |
| 2825 | fn zirTupleDecl( | 2836 | fn zirTupleDecl( |
| 2826 | sema: *Sema, | 2837 | sema: *Sema, |
| 2827 | block: *Block, | 2838 | block: *Block, |
| ... | @@ -15988,13 +15999,19 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -15988,13 +15999,19 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 15988 | | 15999 | |
| 15989 | .@"fn" => { | 16000 | .@"fn" => { |
| 15990 | const fn_info_ty = try sema.getStdLangType(src, .@"Type.Fn"); | 16001 | const fn_info_ty = try sema.getStdLangType(src, .@"Type.Fn"); |
| 15991 | const param_info_ty = try sema.getStdLangType(src, .@"Type.Fn.Param"); | 16002 | const param_attrs_ty = try sema.getStdLangType(src, .@"Type.Fn.ParamAttributes"); |
| | 16003 | const fn_attr_ty = try sema.getStdLangType(src, .@"Type.Fn.Attributes"); |
| 15992 | | 16004 | |
| 15993 | const func_ty_info = zcu.typeToFunc(ty).?; | 16005 | const func_ty_info = zcu.typeToFunc(ty).?; |
| 15994 | const param_vals = try sema.arena.alloc(InternPool.Index, func_ty_info.param_types.len); | 16006 | const param_type_vals = try sema.arena.alloc(InternPool.Index, func_ty_info.param_types.len); |
| | 16007 | const param_attr_vals = try sema.arena.alloc(InternPool.Index, func_ty_info.param_types.len); |
| 15995 | var func_is_generic = false; | 16008 | var func_is_generic = false; |
| 15996 | | 16009 | |
| 15997 | for (param_vals, 0..) |*param_val, param_index| { | 16010 | for ( |
| | 16011 | param_type_vals, |
| | 16012 | param_attr_vals, |
| | 16013 | 0.., |
| | 16014 | ) |*param_type_val, *param_attr_val, param_index| { |
| 15998 | const param_ty = func_ty_info.param_types.get(ip)[param_index]; | 16015 | const param_ty = func_ty_info.param_types.get(ip)[param_index]; |
| 15999 | const is_generic = param_ty == .generic_poison_type; | 16016 | const is_generic = param_ty == .generic_poison_type; |
| 16000 | const is_noalias, const is_comptime = flags: { | 16017 | const is_noalias, const is_comptime = flags: { |
| ... | @@ -16011,25 +16028,23 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16011,25 +16028,23 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16011 | .val = if (is_generic) .none else param_ty, | 16028 | .val = if (is_generic) .none else param_ty, |
| 16012 | } }); | 16029 | } }); |
| 16013 | | 16030 | |
| 16014 | const param_fields = .{ | 16031 | const param_attrs_fields = .{ |
| 16015 | // is_generic: bool, | 16032 | // @"noalias": bool, |
| 16016 | Value.makeBool(is_generic).toIntern(), | | |
| 16017 | // is_noalias: bool, | | |
| 16018 | Value.makeBool(is_noalias).toIntern(), | 16033 | Value.makeBool(is_noalias).toIntern(), |
| 16019 | // type: ?type, | | |
| 16020 | param_ty_val, | | |
| 16021 | }; | 16034 | }; |
| 16022 | param_val.* = (try pt.aggregateValue(param_info_ty, ¶m_fields)).toIntern(); | 16035 | |
| | 16036 | param_type_val.* = param_ty_val; |
| | 16037 | param_attr_val.* = (try pt.aggregateValue(param_attrs_ty, ¶m_attrs_fields)).toIntern(); |
| 16023 | } | 16038 | } |
| 16024 | | 16039 | |
| 16025 | const args_val = v: { | 16040 | const param_types_val = v: { |
| 16026 | const new_decl_ty = try pt.arrayType(.{ | 16041 | const new_decl_ty = try pt.arrayType(.{ |
| 16027 | .len = param_vals.len, | 16042 | .len = param_type_vals.len, |
| 16028 | .child = param_info_ty.toIntern(), | 16043 | .child = try pt.intern(.{ .opt_type = .type_type }), |
| 16029 | }); | 16044 | }); |
| 16030 | const new_decl_val = (try pt.aggregateValue(new_decl_ty, param_vals)).toIntern(); | 16045 | const new_decl_val = (try pt.aggregateValue(new_decl_ty, param_type_vals)).toIntern(); |
| 16031 | const slice_ty = (try pt.ptrType(.{ | 16046 | const slice_ty = (try pt.ptrType(.{ |
| 16032 | .child = param_info_ty.toIntern(), | 16047 | .child = try pt.intern(.{ .opt_type = .type_type }), |
| 16033 | .flags = .{ | 16048 | .flags = .{ |
| 16034 | .size = .slice, | 16049 | .size = .slice, |
| 16035 | .is_const = true, | 16050 | .is_const = true, |
| ... | @@ -16046,7 +16061,34 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16046,7 +16061,34 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16046 | } }, | 16061 | } }, |
| 16047 | .byte_offset = 0, | 16062 | .byte_offset = 0, |
| 16048 | } }), | 16063 | } }), |
| 16049 | .len = (try pt.intValue(.usize, param_vals.len)).toIntern(), | 16064 | .len = (try pt.intValue(.usize, param_type_vals.len)).toIntern(), |
| | 16065 | } }); |
| | 16066 | }; |
| | 16067 | const param_attrs_val = v: { |
| | 16068 | const new_decl_ty = try pt.arrayType(.{ |
| | 16069 | .len = param_attr_vals.len, |
| | 16070 | .child = param_attrs_ty.toIntern(), |
| | 16071 | }); |
| | 16072 | const new_decl_val = (try pt.aggregateValue(new_decl_ty, param_attr_vals)).toIntern(); |
| | 16073 | const slice_ty = (try pt.ptrType(.{ |
| | 16074 | .child = param_attrs_ty.toIntern(), |
| | 16075 | .flags = .{ |
| | 16076 | .size = .slice, |
| | 16077 | .is_const = true, |
| | 16078 | }, |
| | 16079 | })).toIntern(); |
| | 16080 | const manyptr_ty = Type.fromInterned(slice_ty).slicePtrFieldType(zcu).toIntern(); |
| | 16081 | break :v try pt.intern(.{ .slice = .{ |
| | 16082 | .ty = slice_ty, |
| | 16083 | .ptr = try pt.intern(.{ .ptr = .{ |
| | 16084 | .ty = manyptr_ty, |
| | 16085 | .base_addr = .{ .uav = .{ |
| | 16086 | .orig_ty = manyptr_ty, |
| | 16087 | .val = new_decl_val, |
| | 16088 | } }, |
| | 16089 | .byte_offset = 0, |
| | 16090 | } }), |
| | 16091 | .len = (try pt.intValue(.usize, param_attr_vals.len)).toIntern(), |
| 16050 | } }); | 16092 | } }); |
| 16051 | }; | 16093 | }; |
| 16052 | | 16094 | |
| ... | @@ -16075,17 +16117,25 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16075,17 +16117,25 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16075 | error.OutOfMemory => |e| return e, | 16117 | error.OutOfMemory => |e| return e, |
| 16076 | }; | 16118 | }; |
| 16077 | | 16119 | |
| 16078 | const field_values: [5]InternPool.Index = .{ | 16120 | const fn_attrs_values = .{ |
| 16079 | // calling_convention: CallingConvention, | 16121 | // @"callconv": CallingConvention = .auto, |
| 16080 | callconv_val.toIntern(), | 16122 | callconv_val.toIntern(), |
| | 16123 | // varargs: bool = false, |
| | 16124 | Value.makeBool(func_ty_info.is_var_args).toIntern(), |
| | 16125 | }; |
| | 16126 | |
| | 16127 | const field_values = .{ |
| | 16128 | // attrs: Attributes, |
| | 16129 | (try pt.aggregateValue(fn_attr_ty, &fn_attrs_values)).toIntern(), |
| 16081 | // is_generic: bool, | 16130 | // is_generic: bool, |
| 16082 | Value.makeBool(func_is_generic).toIntern(), | 16131 | Value.makeBool(func_is_generic).toIntern(), |
| 16083 | // is_var_args: bool, | | |
| 16084 | Value.makeBool(func_ty_info.is_var_args).toIntern(), | | |
| 16085 | // return_type: ?type, | 16132 | // return_type: ?type, |
| 16086 | ret_ty_opt, | 16133 | ret_ty_opt, |
| 16087 | // args: []const Fn.Param, | 16134 | |
| 16088 | args_val, | 16135 | // param_types: []const ?type, |
| | 16136 | param_types_val, |
| | 16137 | // param_attrs: []const ParamAttributes, |
| | 16138 | param_attrs_val, |
| 16089 | }; | 16139 | }; |
| 16090 | return Air.internedToRef((try pt.internUnion(.{ | 16140 | return Air.internedToRef((try pt.internUnion(.{ |
| 16091 | .ty = type_info_ty.toIntern(), | 16141 | .ty = type_info_ty.toIntern(), |
| ... | @@ -16139,23 +16189,34 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16139,23 +16189,34 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16139 | const addrspace_ty = try sema.getStdLangType(src, .AddressSpace); | 16189 | const addrspace_ty = try sema.getStdLangType(src, .AddressSpace); |
| 16140 | const pointer_ty = try sema.getStdLangType(src, .@"Type.Pointer"); | 16190 | const pointer_ty = try sema.getStdLangType(src, .@"Type.Pointer"); |
| 16141 | const ptr_size_ty = try sema.getStdLangType(src, .@"Type.Pointer.Size"); | 16191 | const ptr_size_ty = try sema.getStdLangType(src, .@"Type.Pointer.Size"); |
| | 16192 | const ptr_attrs_ty = try sema.getStdLangType(src, .@"Type.Pointer.Attributes"); |
| 16142 | | 16193 | |
| 16143 | const field_values = .{ | 16194 | const opt_addrspace_val = try pt.intern(.{ .opt = .{ |
| 16144 | // size: Size, | 16195 | .ty = (try pt.optionalType(addrspace_ty.toIntern())).toIntern(), |
| 16145 | (try pt.enumValueFieldIndex(ptr_size_ty, @intFromEnum(info.flags.size))).toIntern(), | 16196 | .val = (try sema.uninterpretStdLangType(info.flags.address_space, addrspace_ty)).toIntern(), |
| 16146 | // is_const: bool, | 16197 | } }); |
| | 16198 | |
| | 16199 | const attributes = .{ |
| | 16200 | // @"const": bool = false, |
| 16147 | Value.makeBool(info.flags.is_const).toIntern(), | 16201 | Value.makeBool(info.flags.is_const).toIntern(), |
| 16148 | // is_volatile: bool, | 16202 | // @"volatile": bool = false, |
| 16149 | Value.makeBool(info.flags.is_volatile).toIntern(), | 16203 | Value.makeBool(info.flags.is_volatile).toIntern(), |
| 16150 | // alignment: ?usize, | 16204 | // @"allowzero": bool = false, |
| | 16205 | Value.makeBool(info.flags.is_allowzero).toIntern(), |
| | 16206 | // @"addrspace": ?AddressSpace = null, |
| | 16207 | opt_addrspace_val, |
| | 16208 | // @"align": ?usize = null, |
| 16151 | alignment_val.toIntern(), | 16209 | alignment_val.toIntern(), |
| 16152 | // address_space: AddressSpace | 16210 | }; |
| 16153 | (try pt.enumValueFieldIndex(addrspace_ty, @intFromEnum(info.flags.address_space))).toIntern(), | 16211 | |
| | 16212 | const field_values = .{ |
| | 16213 | // size: Size, |
| | 16214 | (try pt.enumValueFieldIndex(ptr_size_ty, @intFromEnum(info.flags.size))).toIntern(), |
| | 16215 | // attrs: Attributes |
| | 16216 | (try pt.aggregateValue(ptr_attrs_ty, &attributes)).toIntern(), |
| 16154 | // child: type, | 16217 | // child: type, |
| 16155 | info.child, | 16218 | info.child, |
| 16156 | // is_allowzero: bool, | 16219 | // sentinel_ptr: ?*const anyopaque, |
| 16157 | Value.makeBool(info.flags.is_allowzero).toIntern(), | | |
| 16158 | // sentinel: ?*const anyopaque, | | |
| 16159 | (try sema.optRefValue(switch (info.sentinel) { | 16220 | (try sema.optRefValue(switch (info.sentinel) { |
| 16160 | .none => null, | 16221 | .none => null, |
| 16161 | else => Value.fromInterned(info.sentinel), | 16222 | else => Value.fromInterned(info.sentinel), |
| ... | @@ -16215,8 +16276,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16215,8 +16276,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16215 | }))); | 16276 | }))); |
| 16216 | }, | 16277 | }, |
| 16217 | .error_set => { | 16278 | .error_set => { |
| 16218 | // Get the Error type | 16279 | const error_set_ty = try sema.getStdLangType(src, .@"Type.ErrorSet"); |
| 16219 | const error_field_ty = try sema.getStdLangType(src, .@"Type.Error"); | | |
| 16220 | | 16280 | |
| 16221 | // Build our list of Error values | 16281 | // Build our list of Error values |
| 16222 | // Optional value is only null if anyerror | 16282 | // Optional value is only null if anyerror |
| ... | @@ -16253,20 +16313,16 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16253,20 +16313,16 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16253 | } }); | 16313 | } }); |
| 16254 | }; | 16314 | }; |
| 16255 | | 16315 | |
| 16256 | const error_field_fields = .{ | 16316 | field_val.* = error_name_val; |
| 16257 | // name: [:0]const u8, | | |
| 16258 | error_name_val, | | |
| 16259 | }; | | |
| 16260 | field_val.* = (try pt.aggregateValue(error_field_ty, &error_field_fields)).toIntern(); | | |
| 16261 | } | 16317 | } |
| 16262 | | 16318 | |
| 16263 | break :blk vals; | 16319 | break :blk vals; |
| 16264 | }, | 16320 | }, |
| 16265 | }; | 16321 | }; |
| 16266 | | 16322 | |
| 16267 | // Build our ?[]const Error value | 16323 | // Build our ?[]const [:0]const u8 value |
| 16268 | const slice_errors_ty = try pt.ptrType(.{ | 16324 | const slice_errors_ty = try pt.ptrType(.{ |
| 16269 | .child = error_field_ty.toIntern(), | 16325 | .child = .slice_const_u8_sentinel_0_type, |
| 16270 | .flags = .{ | 16326 | .flags = .{ |
| 16271 | .size = .slice, | 16327 | .size = .slice, |
| 16272 | .is_const = true, | 16328 | .is_const = true, |
| ... | @@ -16276,7 +16332,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16276,7 +16332,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16276 | const errors_payload_val: InternPool.Index = if (error_field_vals) |vals| v: { | 16332 | const errors_payload_val: InternPool.Index = if (error_field_vals) |vals| v: { |
| 16277 | const array_errors_ty = try pt.arrayType(.{ | 16333 | const array_errors_ty = try pt.arrayType(.{ |
| 16278 | .len = vals.len, | 16334 | .len = vals.len, |
| 16279 | .child = error_field_ty.toIntern(), | 16335 | .child = .slice_const_u8_sentinel_0_type, |
| 16280 | }); | 16336 | }); |
| 16281 | const new_decl_val = (try pt.aggregateValue(array_errors_ty, vals)).toIntern(); | 16337 | const new_decl_val = (try pt.aggregateValue(array_errors_ty, vals)).toIntern(); |
| 16282 | const manyptr_errors_ty = slice_errors_ty.slicePtrFieldType(zcu).toIntern(); | 16338 | const manyptr_errors_ty = slice_errors_ty.slicePtrFieldType(zcu).toIntern(); |
| ... | @@ -16298,11 +16354,16 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16298,11 +16354,16 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16298 | .val = errors_payload_val, | 16354 | .val = errors_payload_val, |
| 16299 | } }); | 16355 | } }); |
| 16300 | | 16356 | |
| | 16357 | const field_values = .{ |
| | 16358 | // error_names: ?[]const [:0]const u8 |
| | 16359 | errors_val, |
| | 16360 | }; |
| | 16361 | |
| 16301 | // Construct Type{ .error_set = errors_val } | 16362 | // Construct Type{ .error_set = errors_val } |
| 16302 | return Air.internedToRef((try pt.internUnion(.{ | 16363 | return Air.internedToRef((try pt.internUnion(.{ |
| 16303 | .ty = type_info_ty.toIntern(), | 16364 | .ty = type_info_ty.toIntern(), |
| 16304 | .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.error_set))).toIntern(), | 16365 | .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.error_set))).toIntern(), |
| 16305 | .val = errors_val, | 16366 | .val = (try pt.aggregateValue(error_set_ty, &field_values)).toIntern(), |
| 16306 | }))); | 16367 | }))); |
| 16307 | }, | 16368 | }, |
| 16308 | .error_union => { | 16369 | .error_union => { |
| ... | @@ -16322,12 +16383,20 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16322,12 +16383,20 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16322 | }, | 16383 | }, |
| 16323 | .@"enum" => { | 16384 | .@"enum" => { |
| 16324 | const enum_obj = ip.loadEnumType(ty.toIntern()); | 16385 | const enum_obj = ip.loadEnumType(ty.toIntern()); |
| 16325 | const is_exhaustive: Value = .makeBool(!enum_obj.nonexhaustive); | | |
| 16326 | | 16386 | |
| 16327 | const enum_field_ty = try sema.getStdLangType(src, .@"Type.EnumField"); | 16387 | const enum_mode_ty = try sema.getStdLangType(src, .@"Type.Enum.Mode"); |
| 16328 | | 16388 | |
| 16329 | const enum_field_vals = try sema.arena.alloc(InternPool.Index, enum_obj.field_names.len); | 16389 | const enum_mode_tag: std.builtin.Type.Enum.Mode = if (enum_obj.nonexhaustive) .nonexhaustive else .exhaustive; |
| 16330 | for (enum_field_vals, 0..) |*field_val, tag_index| { | 16390 | |
| | 16391 | const enum_mode: Value = try sema.uninterpretStdLangType(enum_mode_tag, enum_mode_ty); |
| | 16392 | |
| | 16393 | const enum_field_name_vals = try sema.arena.alloc(InternPool.Index, enum_obj.field_names.len); |
| | 16394 | const enum_field_value_vals = try sema.arena.alloc(InternPool.Index, enum_obj.field_names.len); |
| | 16395 | for ( |
| | 16396 | enum_field_name_vals, |
| | 16397 | enum_field_value_vals, |
| | 16398 | 0.., |
| | 16399 | ) |*field_name_val, *field_value_val, tag_index| { |
| 16331 | const value_val = if (enum_obj.field_values.len > 0) | 16400 | const value_val = if (enum_obj.field_values.len > 0) |
| 16332 | try ip.getCoercedInts( | 16401 | try ip.getCoercedInts( |
| 16333 | gpa, | 16402 | gpa, |
| ... | @@ -16366,23 +16435,18 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16366,23 +16435,18 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16366 | } }); | 16435 | } }); |
| 16367 | }; | 16436 | }; |
| 16368 | | 16437 | |
| 16369 | const enum_field_fields = .{ | 16438 | field_name_val.* = name_val; |
| 16370 | // name: [:0]const u8, | 16439 | field_value_val.* = value_val; |
| 16371 | name_val, | | |
| 16372 | // value: comptime_int, | | |
| 16373 | value_val, | | |
| 16374 | }; | | |
| 16375 | field_val.* = (try pt.aggregateValue(enum_field_ty, &enum_field_fields)).toIntern(); | | |
| 16376 | } | 16440 | } |
| 16377 | | 16441 | |
| 16378 | const fields_val = v: { | 16442 | const fields_names_val = v: { |
| 16379 | const fields_array_ty = try pt.arrayType(.{ | 16443 | const fields_names_array_ty = try pt.arrayType(.{ |
| 16380 | .len = enum_field_vals.len, | 16444 | .len = enum_field_name_vals.len, |
| 16381 | .child = enum_field_ty.toIntern(), | 16445 | .child = .slice_const_u8_sentinel_0_type, |
| 16382 | }); | 16446 | }); |
| 16383 | const new_decl_val = (try pt.aggregateValue(fields_array_ty, enum_field_vals)).toIntern(); | 16447 | const new_decl_val = (try pt.aggregateValue(fields_names_array_ty, enum_field_name_vals)).toIntern(); |
| 16384 | const slice_ty = (try pt.ptrType(.{ | 16448 | const slice_ty = (try pt.ptrType(.{ |
| 16385 | .child = enum_field_ty.toIntern(), | 16449 | .child = .slice_const_u8_sentinel_0_type, |
| 16386 | .flags = .{ | 16450 | .flags = .{ |
| 16387 | .size = .slice, | 16451 | .size = .slice, |
| 16388 | .is_const = true, | 16452 | .is_const = true, |
| ... | @@ -16399,23 +16463,55 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16399,23 +16463,55 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16399 | } }, | 16463 | } }, |
| 16400 | .byte_offset = 0, | 16464 | .byte_offset = 0, |
| 16401 | } }), | 16465 | } }), |
| 16402 | .len = (try pt.intValue(.usize, enum_field_vals.len)).toIntern(), | 16466 | .len = (try pt.intValue(.usize, enum_field_name_vals.len)).toIntern(), |
| 16403 | } }); | 16467 | } }); |
| 16404 | }; | 16468 | }; |
| 16405 | | 16469 | |
| 16406 | const decls_val = try sema.typeInfoDecls(src, ip.loadEnumType(ty.toIntern()).namespace.toOptional()); | 16470 | const fields_values_val = v: { |
| | 16471 | const fields_values_array_ty = try pt.arrayType(.{ |
| | 16472 | .len = enum_field_value_vals.len, |
| | 16473 | .child = .comptime_int_type, |
| | 16474 | }); |
| | 16475 | const new_decl_val = (try pt.aggregateValue(fields_values_array_ty, enum_field_value_vals)).toIntern(); |
| | 16476 | const slice_ty = (try pt.ptrType(.{ |
| | 16477 | .child = .comptime_int_type, |
| | 16478 | .flags = .{ |
| | 16479 | .size = .slice, |
| | 16480 | .is_const = true, |
| | 16481 | }, |
| | 16482 | })).toIntern(); |
| | 16483 | const manyptr_ty = Type.fromInterned(slice_ty).slicePtrFieldType(zcu).toIntern(); |
| | 16484 | break :v try pt.intern(.{ .slice = .{ |
| | 16485 | .ty = slice_ty, |
| | 16486 | .ptr = try pt.intern(.{ .ptr = .{ |
| | 16487 | .ty = manyptr_ty, |
| | 16488 | .base_addr = .{ .uav = .{ |
| | 16489 | .val = new_decl_val, |
| | 16490 | .orig_ty = manyptr_ty, |
| | 16491 | } }, |
| | 16492 | .byte_offset = 0, |
| | 16493 | } }), |
| | 16494 | .len = (try pt.intValue(.usize, enum_field_value_vals.len)).toIntern(), |
| | 16495 | } }); |
| | 16496 | }; |
| | 16497 | |
| | 16498 | const decl_names_val = try sema.typeInfoDecls(ip.loadEnumType(ty.toIntern()).namespace.toOptional()); |
| 16407 | | 16499 | |
| 16408 | const type_enum_ty = try sema.getStdLangType(src, .@"Type.Enum"); | 16500 | const type_enum_ty = try sema.getStdLangType(src, .@"Type.Enum"); |
| 16409 | | 16501 | |
| 16410 | const field_values = .{ | 16502 | const field_values = .{ |
| 16411 | // tag_type: type, | 16503 | // tag_type: type, |
| 16412 | ip.loadEnumType(ty.toIntern()).int_tag_type, | 16504 | ip.loadEnumType(ty.toIntern()).int_tag_type, |
| 16413 | // fields: []const EnumField, | 16505 | // mode: Mode |
| 16414 | fields_val, | 16506 | enum_mode.toIntern(), |
| 16415 | // decls: []const Declaration, | 16507 | |
| 16416 | decls_val, | 16508 | // field_names: []const [:0]const u8, |
| 16417 | // is_exhaustive: bool, | 16509 | fields_names_val, |
| 16418 | is_exhaustive.toIntern(), | 16510 | // field_values: []const comptime_int, |
| | 16511 | fields_values_val, |
| | 16512 | |
| | 16513 | // decl_names: []const [:0]const u8, |
| | 16514 | decl_names_val, |
| 16419 | }; | 16515 | }; |
| 16420 | return Air.internedToRef((try pt.internUnion(.{ | 16516 | return Air.internedToRef((try pt.internUnion(.{ |
| 16421 | .ty = type_info_ty.toIntern(), | 16517 | .ty = type_info_ty.toIntern(), |
| ... | @@ -16425,16 +16521,26 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16425,16 +16521,26 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16425 | }, | 16521 | }, |
| 16426 | .@"union" => { | 16522 | .@"union" => { |
| 16427 | const type_union_ty = try sema.getStdLangType(src, .@"Type.Union"); | 16523 | const type_union_ty = try sema.getStdLangType(src, .@"Type.Union"); |
| 16428 | const union_field_ty = try sema.getStdLangType(src, .@"Type.UnionField"); | 16524 | const union_field_attr_ty = try sema.getStdLangType(src, .@"Type.Union.FieldAttributes"); |
| 16429 | | 16525 | |
| 16430 | const union_obj = ip.loadUnionType(ty.toIntern()); | 16526 | const union_obj = ip.loadUnionType(ty.toIntern()); |
| 16431 | const enum_obj = ip.loadEnumType(union_obj.enum_tag_type); | 16527 | const enum_obj = ip.loadEnumType(union_obj.enum_tag_type); |
| 16432 | const layout = union_obj.layout; | 16528 | const layout = union_obj.layout; |
| 16433 | | 16529 | |
| 16434 | const union_field_vals = try gpa.alloc(InternPool.Index, enum_obj.field_names.len); | 16530 | const union_field_names = try gpa.alloc(InternPool.Index, enum_obj.field_names.len); |
| 16435 | defer gpa.free(union_field_vals); | 16531 | defer gpa.free(union_field_names); |
| 16436 | | 16532 | const union_field_attrs = try gpa.alloc(InternPool.Index, enum_obj.field_names.len); |
| 16437 | for (union_field_vals, 0..) |*field_val, field_index| { | 16533 | defer gpa.free(union_field_attrs); |
| | 16534 | |
| | 16535 | for ( |
| | 16536 | union_field_names, |
| | 16537 | union_field_attrs, |
| | 16538 | 0.., |
| | 16539 | ) | |
| | 16540 | *field_name_val, |
| | 16541 | *field_attr_val, |
| | 16542 | field_index, |
| | 16543 | | { |
| 16438 | const name_val = v: { | 16544 | const name_val = v: { |
| 16439 | const field_name = enum_obj.field_names.get(ip)[field_index]; | 16545 | const field_name = enum_obj.field_names.get(ip)[field_index]; |
| 16440 | const field_name_len = field_name.length(ip); | 16546 | const field_name_len = field_name.length(ip); |
| ... | @@ -16461,8 +16567,6 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16461,8 +16567,6 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16461 | } }); | 16567 | } }); |
| 16462 | }; | 16568 | }; |
| 16463 | | 16569 | |
| 16464 | const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_index]); | | |
| 16465 | | | |
| 16466 | const alignment_ty = try pt.optionalType(.usize_type); | 16570 | const alignment_ty = try pt.optionalType(.usize_type); |
| 16467 | const alignment_val: Value = val: { | 16571 | const alignment_val: Value = val: { |
| 16468 | const a: Alignment = switch (layout) { | 16572 | const a: Alignment = switch (layout) { |
| ... | @@ -16479,25 +16583,52 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16479,25 +16583,52 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16479 | } })); | 16583 | } })); |
| 16480 | }; | 16584 | }; |
| 16481 | | 16585 | |
| 16482 | const union_field_fields = .{ | 16586 | field_name_val.* = name_val; |
| 16483 | // name: [:0]const u8, | 16587 | const union_field_attr = .{ |
| 16484 | name_val, | | |
| 16485 | // type: type, | | |
| 16486 | field_ty.toIntern(), | | |
| 16487 | // alignment: ?usize, | 16588 | // alignment: ?usize, |
| 16488 | alignment_val.toIntern(), | 16589 | alignment_val.toIntern(), |
| 16489 | }; | 16590 | }; |
| 16490 | field_val.* = (try pt.aggregateValue(union_field_ty, &union_field_fields)).toIntern(); | 16591 | |
| | 16592 | field_attr_val.* = (try pt.aggregateValue(union_field_attr_ty, &union_field_attr)).toIntern(); |
| 16491 | } | 16593 | } |
| 16492 | | 16594 | |
| 16493 | const fields_val = v: { | 16595 | const field_names_val = v: { |
| | 16596 | const array_field_names_ty = try pt.arrayType(.{ |
| | 16597 | .len = union_field_names.len, |
| | 16598 | .child = .slice_const_u8_sentinel_0_type, |
| | 16599 | }); |
| | 16600 | const new_decl_val = (try pt.aggregateValue(array_field_names_ty, union_field_names)).toIntern(); |
| | 16601 | const slice_ty = (try pt.ptrType(.{ |
| | 16602 | .child = .slice_const_u8_sentinel_0_type, |
| | 16603 | .flags = .{ |
| | 16604 | .size = .slice, |
| | 16605 | .is_const = true, |
| | 16606 | }, |
| | 16607 | })).toIntern(); |
| | 16608 | const manyptr_ty = Type.fromInterned(slice_ty).slicePtrFieldType(zcu).toIntern(); |
| | 16609 | break :v try pt.intern(.{ .slice = .{ |
| | 16610 | .ty = slice_ty, |
| | 16611 | .ptr = try pt.intern(.{ .ptr = .{ |
| | 16612 | .ty = manyptr_ty, |
| | 16613 | .base_addr = .{ .uav = .{ |
| | 16614 | .orig_ty = manyptr_ty, |
| | 16615 | .val = new_decl_val, |
| | 16616 | } }, |
| | 16617 | .byte_offset = 0, |
| | 16618 | } }), |
| | 16619 | .len = (try pt.intValue(.usize, union_field_names.len)).toIntern(), |
| | 16620 | } }); |
| | 16621 | }; |
| | 16622 | const field_types_val = v: { |
| | 16623 | const union_field_types = union_obj.field_types.get(ip); |
| | 16624 | |
| 16494 | const array_fields_ty = try pt.arrayType(.{ | 16625 | const array_fields_ty = try pt.arrayType(.{ |
| 16495 | .len = union_field_vals.len, | 16626 | .len = union_field_types.len, |
| 16496 | .child = union_field_ty.toIntern(), | 16627 | .child = .type_type, |
| 16497 | }); | 16628 | }); |
| 16498 | const new_decl_val = (try pt.aggregateValue(array_fields_ty, union_field_vals)).toIntern(); | 16629 | const new_decl_val = (try pt.aggregateValue(array_fields_ty, union_field_types)).toIntern(); |
| 16499 | const slice_ty = (try pt.ptrType(.{ | 16630 | const slice_ty = (try pt.ptrType(.{ |
| 16500 | .child = union_field_ty.toIntern(), | 16631 | .child = .type_type, |
| 16501 | .flags = .{ | 16632 | .flags = .{ |
| 16502 | .size = .slice, | 16633 | .size = .slice, |
| 16503 | .is_const = true, | 16634 | .is_const = true, |
| ... | @@ -16514,11 +16645,38 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16514,11 +16645,38 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16514 | } }, | 16645 | } }, |
| 16515 | .byte_offset = 0, | 16646 | .byte_offset = 0, |
| 16516 | } }), | 16647 | } }), |
| 16517 | .len = (try pt.intValue(.usize, union_field_vals.len)).toIntern(), | 16648 | .len = (try pt.intValue(.usize, union_field_types.len)).toIntern(), |
| | 16649 | } }); |
| | 16650 | }; |
| | 16651 | const field_attrs_val = v: { |
| | 16652 | const array_fields_ty = try pt.arrayType(.{ |
| | 16653 | .len = union_field_attrs.len, |
| | 16654 | .child = union_field_attr_ty.toIntern(), |
| | 16655 | }); |
| | 16656 | const new_decl_val = (try pt.aggregateValue(array_fields_ty, union_field_attrs)).toIntern(); |
| | 16657 | const slice_ty = (try pt.ptrType(.{ |
| | 16658 | .child = union_field_attr_ty.toIntern(), |
| | 16659 | .flags = .{ |
| | 16660 | .size = .slice, |
| | 16661 | .is_const = true, |
| | 16662 | }, |
| | 16663 | })).toIntern(); |
| | 16664 | const manyptr_ty = Type.fromInterned(slice_ty).slicePtrFieldType(zcu).toIntern(); |
| | 16665 | break :v try pt.intern(.{ .slice = .{ |
| | 16666 | .ty = slice_ty, |
| | 16667 | .ptr = try pt.intern(.{ .ptr = .{ |
| | 16668 | .ty = manyptr_ty, |
| | 16669 | .base_addr = .{ .uav = .{ |
| | 16670 | .orig_ty = manyptr_ty, |
| | 16671 | .val = new_decl_val, |
| | 16672 | } }, |
| | 16673 | .byte_offset = 0, |
| | 16674 | } }), |
| | 16675 | .len = (try pt.intValue(.usize, union_field_attrs.len)).toIntern(), |
| 16518 | } }); | 16676 | } }); |
| 16519 | }; | 16677 | }; |
| 16520 | | 16678 | |
| 16521 | const decls_val = try sema.typeInfoDecls(src, ty.getNamespaceIndex(zcu).toOptional()); | 16679 | const decl_names_val = try sema.typeInfoDecls(ty.getNamespaceIndex(zcu).toOptional()); |
| 16522 | | 16680 | |
| 16523 | const enum_tag_ty_val = try pt.intern(.{ .opt = .{ | 16681 | const enum_tag_ty_val = try pt.intern(.{ .opt = .{ |
| 16524 | .ty = (try pt.optionalType(.type_type)).toIntern(), | 16682 | .ty = (try pt.optionalType(.type_type)).toIntern(), |
| ... | @@ -16527,16 +16685,32 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16527,16 +16685,32 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16527 | | 16685 | |
| 16528 | const container_layout_ty = try sema.getStdLangType(src, .@"Type.ContainerLayout"); | 16686 | const container_layout_ty = try sema.getStdLangType(src, .@"Type.ContainerLayout"); |
| 16529 | | 16687 | |
| | 16688 | const backing_integer_val = try pt.intern(.{ .opt = .{ |
| | 16689 | .ty = (try pt.optionalType(.type_type)).toIntern(), |
| | 16690 | .val = if (layout == .@"packed") val: { |
| | 16691 | assert(Type.fromInterned(union_obj.packed_backing_int_type).isInt(zcu)); |
| | 16692 | break :val union_obj.packed_backing_int_type; |
| | 16693 | } else .none, |
| | 16694 | } }); |
| | 16695 | |
| 16530 | const field_values = .{ | 16696 | const field_values = .{ |
| 16531 | // layout: ContainerLayout, | 16697 | // layout: ContainerLayout, |
| 16532 | (try pt.enumValueFieldIndex(container_layout_ty, @intFromEnum(layout))).toIntern(), | 16698 | (try pt.enumValueFieldIndex(container_layout_ty, @intFromEnum(layout))).toIntern(), |
| 16533 | | 16699 | |
| 16534 | // tag_type: ?type, | 16700 | // tag_type: ?type, |
| 16535 | enum_tag_ty_val, | 16701 | enum_tag_ty_val, |
| 16536 | // fields: []const UnionField, | 16702 | // backing_integer: ?type, |
| 16537 | fields_val, | 16703 | backing_integer_val, |
| 16538 | // decls: []const Declaration, | 16704 | |
| 16539 | decls_val, | 16705 | // field_names: []const [:0]const u8, |
| | 16706 | field_names_val, |
| | 16707 | // field_types: []const type, |
| | 16708 | field_types_val, |
| | 16709 | // field_attrs: []const FieldAttributes, |
| | 16710 | field_attrs_val, |
| | 16711 | |
| | 16712 | // decl_names: []const [:0]const u8, |
| | 16713 | decl_names_val, |
| 16540 | }; | 16714 | }; |
| 16541 | return Air.internedToRef((try pt.internUnion(.{ | 16715 | return Air.internedToRef((try pt.internUnion(.{ |
| 16542 | .ty = type_info_ty.toIntern(), | 16716 | .ty = type_info_ty.toIntern(), |
| ... | @@ -16546,16 +16720,26 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16546,16 +16720,26 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16546 | }, | 16720 | }, |
| 16547 | .@"struct" => { | 16721 | .@"struct" => { |
| 16548 | const type_struct_ty = try sema.getStdLangType(src, .@"Type.Struct"); | 16722 | const type_struct_ty = try sema.getStdLangType(src, .@"Type.Struct"); |
| 16549 | const struct_field_ty = try sema.getStdLangType(src, .@"Type.StructField"); | 16723 | const struct_field_attr_ty = try sema.getStdLangType(src, .@"Type.Struct.FieldAttributes"); |
| 16550 | | 16724 | |
| 16551 | var struct_field_vals: []InternPool.Index = &.{}; | 16725 | var struct_field_name_vals: []InternPool.Index = &.{}; |
| 16552 | defer gpa.free(struct_field_vals); | 16726 | defer gpa.free(struct_field_name_vals); |
| | 16727 | var struct_field_attr_vals: []InternPool.Index = &.{}; |
| | 16728 | defer gpa.free(struct_field_attr_vals); |
| 16553 | fv: { | 16729 | fv: { |
| 16554 | const struct_type = switch (ip.indexToKey(ty.toIntern())) { | 16730 | const struct_type = switch (ip.indexToKey(ty.toIntern())) { |
| 16555 | .tuple_type => |tuple_type| { | 16731 | .tuple_type => |tuple_type| { |
| 16556 | struct_field_vals = try gpa.alloc(InternPool.Index, tuple_type.types.len); | 16732 | struct_field_name_vals = try gpa.alloc(InternPool.Index, tuple_type.types.len); |
| 16557 | for (struct_field_vals, 0..) |*struct_field_val, field_index| { | 16733 | struct_field_attr_vals = try gpa.alloc(InternPool.Index, tuple_type.types.len); |
| 16558 | const field_ty = tuple_type.types.get(ip)[field_index]; | 16734 | for ( |
| | 16735 | struct_field_name_vals, |
| | 16736 | struct_field_attr_vals, |
| | 16737 | 0.., |
| | 16738 | ) | |
| | 16739 | *struct_field_name_val, |
| | 16740 | *struct_field_attr_val, |
| | 16741 | field_index, |
| | 16742 | | { |
| 16559 | const field_val = tuple_type.values.get(ip)[field_index]; | 16743 | const field_val = tuple_type.values.get(ip)[field_index]; |
| 16560 | const name_val = v: { | 16744 | const name_val = v: { |
| 16561 | const field_name = try ip.getOrPutStringFmt(gpa, io, pt.tid, "{d}", .{field_index}, .no_embedded_nulls); | 16745 | const field_name = try ip.getOrPutStringFmt(gpa, io, pt.tid, "{d}", .{field_index}, .no_embedded_nulls); |
| ... | @@ -16587,19 +16771,17 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16587,19 +16771,17 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16587 | const opt_default_val = if (is_comptime) Value.fromInterned(field_val) else null; | 16771 | const opt_default_val = if (is_comptime) Value.fromInterned(field_val) else null; |
| 16588 | const default_val_ptr = try sema.optRefValue(opt_default_val); | 16772 | const default_val_ptr = try sema.optRefValue(opt_default_val); |
| 16589 | | 16773 | |
| 16590 | const struct_field_fields = .{ | 16774 | const struct_field_attr_fields = .{ |
| 16591 | // name: [:0]const u8, | 16775 | // @"comptime": bool, |
| 16592 | name_val, | | |
| 16593 | // type: type, | | |
| 16594 | field_ty, | | |
| 16595 | // default_value: ?*const anyopaque, | | |
| 16596 | default_val_ptr.toIntern(), | | |
| 16597 | // is_comptime: bool, | | |
| 16598 | Value.makeBool(is_comptime).toIntern(), | 16776 | Value.makeBool(is_comptime).toIntern(), |
| 16599 | // alignment: ?usize, | 16777 | // @"align": ?usize, |
| 16600 | (try pt.nullValue(try pt.optionalType(.usize_type))).toIntern(), | 16778 | (try pt.nullValue(try pt.optionalType(.usize_type))).toIntern(), |
| | 16779 | // default_value_ptr: ?*const anyopaque, |
| | 16780 | default_val_ptr.toIntern(), |
| 16601 | }; | 16781 | }; |
| 16602 | struct_field_val.* = (try pt.aggregateValue(struct_field_ty, &struct_field_fields)).toIntern(); | 16782 | |
| | 16783 | struct_field_name_val.* = name_val; |
| | 16784 | struct_field_attr_val.* = (try pt.aggregateValue(struct_field_attr_ty, &struct_field_attr_fields)).toIntern(); |
| 16603 | } | 16785 | } |
| 16604 | break :fv; | 16786 | break :fv; |
| 16605 | }, | 16787 | }, |
| ... | @@ -16607,12 +16789,20 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16607,12 +16789,20 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16607 | else => unreachable, | 16789 | else => unreachable, |
| 16608 | }; | 16790 | }; |
| 16609 | try sema.ensureStructDefaultsResolved(ty, src); // can't do this sooner, since it's not allowed on tuples | 16791 | try sema.ensureStructDefaultsResolved(ty, src); // can't do this sooner, since it's not allowed on tuples |
| 16610 | struct_field_vals = try gpa.alloc(InternPool.Index, struct_type.field_types.len); | 16792 | struct_field_name_vals = try gpa.alloc(InternPool.Index, struct_type.field_types.len); |
| 16611 | | 16793 | struct_field_attr_vals = try gpa.alloc(InternPool.Index, struct_type.field_types.len); |
| 16612 | for (struct_field_vals, 0..) |*field_val, field_index| { | 16794 | |
| | 16795 | for ( |
| | 16796 | struct_field_name_vals, |
| | 16797 | struct_field_attr_vals, |
| | 16798 | 0.., |
| | 16799 | ) | |
| | 16800 | *field_name_val, |
| | 16801 | *field_attr_val, |
| | 16802 | field_index, |
| | 16803 | | { |
| 16613 | const field_name = struct_type.field_names.get(ip)[field_index]; | 16804 | const field_name = struct_type.field_names.get(ip)[field_index]; |
| 16614 | const field_name_len = field_name.length(ip); | 16805 | const field_name_len = field_name.length(ip); |
| 16615 | const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[field_index]); | | |
| 16616 | const field_default: InternPool.Index = if (struct_type.field_defaults.len > 0) d: { | 16806 | const field_default: InternPool.Index = if (struct_type.field_defaults.len > 0) d: { |
| 16617 | break :d struct_type.field_defaults.get(ip)[field_index]; | 16807 | break :d struct_type.field_defaults.get(ip)[field_index]; |
| 16618 | } else .none; | 16808 | } else .none; |
| ... | @@ -16660,30 +16850,63 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16660,30 +16850,63 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16660 | } })); | 16850 | } })); |
| 16661 | }; | 16851 | }; |
| 16662 | | 16852 | |
| 16663 | const struct_field_fields = .{ | 16853 | const struct_field_attr_fields = .{ |
| 16664 | // name: [:0]const u8, | 16854 | // @"comptime": bool, |
| 16665 | name_val, | | |
| 16666 | // type: type, | | |
| 16667 | field_ty.toIntern(), | | |
| 16668 | // default_value: ?*const anyopaque, | | |
| 16669 | default_val_ptr.toIntern(), | | |
| 16670 | // is_comptime: bool, | | |
| 16671 | Value.makeBool(field_is_comptime).toIntern(), | 16855 | Value.makeBool(field_is_comptime).toIntern(), |
| 16672 | // alignment: ?usize, | 16856 | // @"align": ?usize, |
| 16673 | alignment_val.toIntern(), | 16857 | alignment_val.toIntern(), |
| | 16858 | // default_value_ptr: ?*const anyopaque, |
| | 16859 | default_val_ptr.toIntern(), |
| 16674 | }; | 16860 | }; |
| 16675 | field_val.* = (try pt.aggregateValue(struct_field_ty, &struct_field_fields)).toIntern(); | 16861 | field_name_val.* = name_val; |
| | 16862 | field_attr_val.* = (try pt.aggregateValue(struct_field_attr_ty, &struct_field_attr_fields)).toIntern(); |
| 16676 | } | 16863 | } |
| 16677 | } | 16864 | } |
| 16678 | | 16865 | |
| 16679 | const fields_val = v: { | 16866 | const field_names_val = v: { |
| | 16867 | const array_fields_ty = try pt.arrayType(.{ |
| | 16868 | .len = struct_field_name_vals.len, |
| | 16869 | .child = .slice_const_u8_sentinel_0_type, |
| | 16870 | }); |
| | 16871 | const new_decl_val = (try pt.aggregateValue(array_fields_ty, struct_field_name_vals)).toIntern(); |
| | 16872 | const slice_ty = (try pt.ptrType(.{ |
| | 16873 | .child = .slice_const_u8_sentinel_0_type, |
| | 16874 | .flags = .{ |
| | 16875 | .size = .slice, |
| | 16876 | .is_const = true, |
| | 16877 | }, |
| | 16878 | })).toIntern(); |
| | 16879 | const manyptr_ty = Type.fromInterned(slice_ty).slicePtrFieldType(zcu).toIntern(); |
| | 16880 | break :v try pt.intern(.{ .slice = .{ |
| | 16881 | .ty = slice_ty, |
| | 16882 | .ptr = try pt.intern(.{ .ptr = .{ |
| | 16883 | .ty = manyptr_ty, |
| | 16884 | .base_addr = .{ .uav = .{ |
| | 16885 | .orig_ty = manyptr_ty, |
| | 16886 | .val = new_decl_val, |
| | 16887 | } }, |
| | 16888 | .byte_offset = 0, |
| | 16889 | } }), |
| | 16890 | .len = (try pt.intValue(.usize, struct_field_name_vals.len)).toIntern(), |
| | 16891 | } }); |
| | 16892 | }; |
| | 16893 | |
| | 16894 | const field_types_val = v: { |
| | 16895 | const struct_field_type_vals = switch (ip.indexToKey(ty.toIntern())) { |
| | 16896 | .tuple_type => |tt| tt.types.get(ip), |
| | 16897 | .struct_type => blk: { |
| | 16898 | const st = ip.loadStructType(ty.toIntern()); |
| | 16899 | break :blk st.field_types.get(ip); |
| | 16900 | }, |
| | 16901 | else => unreachable, |
| | 16902 | }; |
| 16680 | const array_fields_ty = try pt.arrayType(.{ | 16903 | const array_fields_ty = try pt.arrayType(.{ |
| 16681 | .len = struct_field_vals.len, | 16904 | .len = struct_field_type_vals.len, |
| 16682 | .child = struct_field_ty.toIntern(), | 16905 | .child = .type_type, |
| 16683 | }); | 16906 | }); |
| 16684 | const new_decl_val = (try pt.aggregateValue(array_fields_ty, struct_field_vals)).toIntern(); | 16907 | const new_decl_val = (try pt.aggregateValue(array_fields_ty, struct_field_type_vals)).toIntern(); |
| 16685 | const slice_ty = (try pt.ptrType(.{ | 16908 | const slice_ty = (try pt.ptrType(.{ |
| 16686 | .child = struct_field_ty.toIntern(), | 16909 | .child = .type_type, |
| 16687 | .flags = .{ | 16910 | .flags = .{ |
| 16688 | .size = .slice, | 16911 | .size = .slice, |
| 16689 | .is_const = true, | 16912 | .is_const = true, |
| ... | @@ -16700,11 +16923,38 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16700,11 +16923,38 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16700 | } }, | 16923 | } }, |
| 16701 | .byte_offset = 0, | 16924 | .byte_offset = 0, |
| 16702 | } }), | 16925 | } }), |
| 16703 | .len = (try pt.intValue(.usize, struct_field_vals.len)).toIntern(), | 16926 | .len = (try pt.intValue(.usize, struct_field_type_vals.len)).toIntern(), |
| | 16927 | } }); |
| | 16928 | }; |
| | 16929 | const field_attrs_val = v: { |
| | 16930 | const array_fields_ty = try pt.arrayType(.{ |
| | 16931 | .len = struct_field_attr_vals.len, |
| | 16932 | .child = struct_field_attr_ty.toIntern(), |
| | 16933 | }); |
| | 16934 | const new_decl_val = (try pt.aggregateValue(array_fields_ty, struct_field_attr_vals)).toIntern(); |
| | 16935 | const slice_ty = (try pt.ptrType(.{ |
| | 16936 | .child = struct_field_attr_ty.toIntern(), |
| | 16937 | .flags = .{ |
| | 16938 | .size = .slice, |
| | 16939 | .is_const = true, |
| | 16940 | }, |
| | 16941 | })).toIntern(); |
| | 16942 | const manyptr_ty = Type.fromInterned(slice_ty).slicePtrFieldType(zcu).toIntern(); |
| | 16943 | break :v try pt.intern(.{ .slice = .{ |
| | 16944 | .ty = slice_ty, |
| | 16945 | .ptr = try pt.intern(.{ .ptr = .{ |
| | 16946 | .ty = manyptr_ty, |
| | 16947 | .base_addr = .{ .uav = .{ |
| | 16948 | .orig_ty = manyptr_ty, |
| | 16949 | .val = new_decl_val, |
| | 16950 | } }, |
| | 16951 | .byte_offset = 0, |
| | 16952 | } }), |
| | 16953 | .len = (try pt.intValue(.usize, struct_field_attr_vals.len)).toIntern(), |
| 16704 | } }); | 16954 | } }); |
| 16705 | }; | 16955 | }; |
| 16706 | | 16956 | |
| 16707 | const decls_val = try sema.typeInfoDecls(src, ty.getNamespace(zcu)); | 16957 | const decl_names_val = try sema.typeInfoDecls(ty.getNamespace(zcu)); |
| 16708 | | 16958 | |
| 16709 | const backing_integer_val = try pt.intern(.{ .opt = .{ | 16959 | const backing_integer_val = try pt.intern(.{ .opt = .{ |
| 16710 | .ty = (try pt.optionalType(.type_type)).toIntern(), | 16960 | .ty = (try pt.optionalType(.type_type)).toIntern(), |
| ... | @@ -16719,16 +16969,22 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16719,16 +16969,22 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16719 | const layout = ty.containerLayout(zcu); | 16969 | const layout = ty.containerLayout(zcu); |
| 16720 | | 16970 | |
| 16721 | const field_values = [_]InternPool.Index{ | 16971 | const field_values = [_]InternPool.Index{ |
| | 16972 | // is_tuple: bool, |
| | 16973 | Value.makeBool(ty.isTuple(zcu)).toIntern(), |
| 16722 | // layout: ContainerLayout, | 16974 | // layout: ContainerLayout, |
| 16723 | (try pt.enumValueFieldIndex(container_layout_ty, @intFromEnum(layout))).toIntern(), | 16975 | (try pt.enumValueFieldIndex(container_layout_ty, @intFromEnum(layout))).toIntern(), |
| 16724 | // backing_integer: ?type, | 16976 | // backing_integer: ?type, |
| 16725 | backing_integer_val, | 16977 | backing_integer_val, |
| 16726 | // fields: []const StructField, | 16978 | |
| 16727 | fields_val, | 16979 | // field_names: []const [:0]const u8, |
| 16728 | // decls: []const Declaration, | 16980 | field_names_val, |
| 16729 | decls_val, | 16981 | // field_types: []const type, |
| 16730 | // is_tuple: bool, | 16982 | field_types_val, |
| 16731 | Value.makeBool(ty.isTuple(zcu)).toIntern(), | 16983 | // field_attrs: []const FieldAttributes, |
| | 16984 | field_attrs_val, |
| | 16985 | |
| | 16986 | // decl_names: []const [:0]const u8, |
| | 16987 | decl_names_val, |
| 16732 | }; | 16988 | }; |
| 16733 | return Air.internedToRef((try pt.internUnion(.{ | 16989 | return Air.internedToRef((try pt.internUnion(.{ |
| 16734 | .ty = type_info_ty.toIntern(), | 16990 | .ty = type_info_ty.toIntern(), |
| ... | @@ -16739,11 +16995,11 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16739,11 +16995,11 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16739 | .@"opaque" => { | 16995 | .@"opaque" => { |
| 16740 | const type_opaque_ty = try sema.getStdLangType(src, .@"Type.Opaque"); | 16996 | const type_opaque_ty = try sema.getStdLangType(src, .@"Type.Opaque"); |
| 16741 | | 16997 | |
| 16742 | const decls_val = try sema.typeInfoDecls(src, ty.getNamespace(zcu)); | 16998 | const decl_names_val = try sema.typeInfoDecls(ty.getNamespace(zcu)); |
| 16743 | | 16999 | |
| 16744 | const field_values = .{ | 17000 | const field_values = .{ |
| 16745 | // decls: []const Declaration, | 17001 | // decl_names: []const [:0]const u8, |
| 16746 | decls_val, | 17002 | decl_names_val, |
| 16747 | }; | 17003 | }; |
| 16748 | return Air.internedToRef((try pt.internUnion(.{ | 17004 | return Air.internedToRef((try pt.internUnion(.{ |
| 16749 | .ty = type_info_ty.toIntern(), | 17005 | .ty = type_info_ty.toIntern(), |
| ... | @@ -16758,30 +17014,27 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai | ... | @@ -16758,30 +17014,27 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16758 | | 17014 | |
| 16759 | fn typeInfoDecls( | 17015 | fn typeInfoDecls( |
| 16760 | sema: *Sema, | 17016 | sema: *Sema, |
| 16761 | src: LazySrcLoc, | | |
| 16762 | opt_namespace: InternPool.OptionalNamespaceIndex, | 17017 | opt_namespace: InternPool.OptionalNamespaceIndex, |
| 16763 | ) CompileError!InternPool.Index { | 17018 | ) CompileError!InternPool.Index { |
| 16764 | const pt = sema.pt; | 17019 | const pt = sema.pt; |
| 16765 | const zcu = pt.zcu; | 17020 | const zcu = pt.zcu; |
| 16766 | const gpa = sema.gpa; | 17021 | const gpa = sema.gpa; |
| 16767 | | 17022 | |
| 16768 | const declaration_ty = try sema.getStdLangType(src, .@"Type.Declaration"); | | |
| 16769 | | | |
| 16770 | var decl_vals = std.array_list.Managed(InternPool.Index).init(gpa); | 17023 | var decl_vals = std.array_list.Managed(InternPool.Index).init(gpa); |
| 16771 | defer decl_vals.deinit(); | 17024 | defer decl_vals.deinit(); |
| 16772 | | 17025 | |
| 16773 | var seen_namespaces = std.AutoHashMap(*Namespace, void).init(gpa); | 17026 | var seen_namespaces = std.AutoHashMap(*Namespace, void).init(gpa); |
| 16774 | defer seen_namespaces.deinit(); | 17027 | defer seen_namespaces.deinit(); |
| 16775 | | 17028 | |
| 16776 | try sema.typeInfoNamespaceDecls(opt_namespace, declaration_ty, &decl_vals, &seen_namespaces); | 17029 | try sema.typeInfoNamespaceDecls(opt_namespace, &decl_vals, &seen_namespaces); |
| 16777 | | 17030 | |
| 16778 | const array_decl_ty = try pt.arrayType(.{ | 17031 | const array_decl_ty = try pt.arrayType(.{ |
| 16779 | .len = decl_vals.items.len, | 17032 | .len = decl_vals.items.len, |
| 16780 | .child = declaration_ty.toIntern(), | 17033 | .child = .slice_const_u8_sentinel_0_type, |
| 16781 | }); | 17034 | }); |
| 16782 | const new_decl_val = (try pt.aggregateValue(array_decl_ty, decl_vals.items)).toIntern(); | 17035 | const new_decl_val = (try pt.aggregateValue(array_decl_ty, decl_vals.items)).toIntern(); |
| 16783 | const slice_ty = (try pt.ptrType(.{ | 17036 | const slice_ty = (try pt.ptrType(.{ |
| 16784 | .child = declaration_ty.toIntern(), | 17037 | .child = .slice_const_u8_sentinel_0_type, |
| 16785 | .flags = .{ | 17038 | .flags = .{ |
| 16786 | .size = .slice, | 17039 | .size = .slice, |
| 16787 | .is_const = true, | 17040 | .is_const = true, |
| ... | @@ -16805,7 +17058,6 @@ fn typeInfoDecls( | ... | @@ -16805,7 +17058,6 @@ fn typeInfoDecls( |
| 16805 | fn typeInfoNamespaceDecls( | 17058 | fn typeInfoNamespaceDecls( |
| 16806 | sema: *Sema, | 17059 | sema: *Sema, |
| 16807 | opt_namespace_index: InternPool.OptionalNamespaceIndex, | 17060 | opt_namespace_index: InternPool.OptionalNamespaceIndex, |
| 16808 | declaration_ty: Type, | | |
| 16809 | decl_vals: *std.array_list.Managed(InternPool.Index), | 17061 | decl_vals: *std.array_list.Managed(InternPool.Index), |
| 16810 | seen_namespaces: *std.AutoHashMap(*Namespace, void), | 17062 | seen_namespaces: *std.AutoHashMap(*Namespace, void), |
| 16811 | ) !void { | 17063 | ) !void { |
| ... | @@ -16850,11 +17102,7 @@ fn typeInfoNamespaceDecls( | ... | @@ -16850,11 +17102,7 @@ fn typeInfoNamespaceDecls( |
| 16850 | }, | 17102 | }, |
| 16851 | }); | 17103 | }); |
| 16852 | }; | 17104 | }; |
| 16853 | const fields = [_]InternPool.Index{ | 17105 | try decl_vals.append(name_val); |
| 16854 | // name: [:0]const u8, | | |
| 16855 | name_val, | | |
| 16856 | }; | | |
| 16857 | try decl_vals.append((try pt.aggregateValue(declaration_ty, &fields)).toIntern()); | | |
| 16858 | } | 17106 | } |
| 16859 | } | 17107 | } |
| 16860 | | 17108 | |
| ... | @@ -19470,11 +19718,11 @@ fn zirReifySliceArgTy( | ... | @@ -19470,11 +19718,11 @@ fn zirReifySliceArgTy( |
| 19470 | | 19718 | |
| 19471 | const comptime_reason: std.zig.SimpleComptimeReason, const in_scalar_ty: Type, const out_scalar_ty: Type = switch (info) { | 19719 | const comptime_reason: std.zig.SimpleComptimeReason, const in_scalar_ty: Type, const out_scalar_ty: Type = switch (info) { |
| 19472 | // zig fmt: off | 19720 | // zig fmt: off |
| 19473 | .type_to_fn_param_attrs => .{ .fn_param_attrs, .type, try sema.getStdLangType(src, .@"Type.Fn.Param.Attributes") }, | 19721 | .type_to_fn_param_attrs => .{ .fn_param_attrs, .type, try sema.getStdLangType(src, .@"Type.Fn.ParamAttributes") }, |
| 19474 | .string_to_struct_field_type => .{ .struct_field_types, .slice_const_u8, .type }, | 19722 | .string_to_struct_field_type => .{ .struct_field_types, .slice_const_u8, .type }, |
| 19475 | .string_to_union_field_type => .{ .union_field_types, .slice_const_u8, .type }, | 19723 | .string_to_union_field_type => .{ .union_field_types, .slice_const_u8, .type }, |
| 19476 | .string_to_struct_field_attrs => .{ .struct_field_attrs, .slice_const_u8, try sema.getStdLangType(src, .@"Type.StructField.Attributes") }, | 19724 | .string_to_struct_field_attrs => .{ .struct_field_attrs, .slice_const_u8, try sema.getStdLangType(src, .@"Type.Struct.FieldAttributes") }, |
| 19477 | .string_to_union_field_attrs => .{ .union_field_attrs, .slice_const_u8, try sema.getStdLangType(src, .@"Type.UnionField.Attributes") }, | 19725 | .string_to_union_field_attrs => .{ .union_field_attrs, .slice_const_u8, try sema.getStdLangType(src, .@"Type.Union.FieldAttributes") }, |
| 19478 | // zig fmt: on | 19726 | // zig fmt: on |
| 19479 | }; | 19727 | }; |
| 19480 | | 19728 | |
| ... | @@ -19688,7 +19936,7 @@ fn zirReifyFn( | ... | @@ -19688,7 +19936,7 @@ fn zirReifyFn( |
| 19688 | const ret_ty_src = block.builtinCallArgSrc(extra.node, 2); | 19936 | const ret_ty_src = block.builtinCallArgSrc(extra.node, 2); |
| 19689 | const fn_attrs_src = block.builtinCallArgSrc(extra.node, 3); | 19937 | const fn_attrs_src = block.builtinCallArgSrc(extra.node, 3); |
| 19690 | | 19938 | |
| 19691 | const single_param_attrs_ty = try sema.getStdLangType(param_attrs_src, .@"Type.Fn.Param.Attributes"); | 19939 | const single_param_attrs_ty = try sema.getStdLangType(param_attrs_src, .@"Type.Fn.ParamAttributes"); |
| 19692 | const fn_attrs_ty = try sema.getStdLangType(fn_attrs_src, .@"Type.Fn.Attributes"); | 19940 | const fn_attrs_ty = try sema.getStdLangType(fn_attrs_src, .@"Type.Fn.Attributes"); |
| 19693 | | 19941 | |
| 19694 | const param_types_uncoerced = sema.resolveInst(extra.param_types); | 19942 | const param_types_uncoerced = sema.resolveInst(extra.param_types); |
| ... | @@ -19827,7 +20075,7 @@ fn zirReifyStruct( | ... | @@ -19827,7 +20075,7 @@ fn zirReifyStruct( |
| 19827 | }; | 20075 | }; |
| 19828 | | 20076 | |
| 19829 | const container_layout_ty = try sema.getStdLangType(layout_src, .@"Type.ContainerLayout"); | 20077 | const container_layout_ty = try sema.getStdLangType(layout_src, .@"Type.ContainerLayout"); |
| 19830 | const single_field_attrs_ty = try sema.getStdLangType(field_attrs_src, .@"Type.StructField.Attributes"); | 20078 | const single_field_attrs_ty = try sema.getStdLangType(field_attrs_src, .@"Type.Struct.FieldAttributes"); |
| 19831 | | 20079 | |
| 19832 | const layout_uncoerced = sema.resolveInst(extra.layout); | 20080 | const layout_uncoerced = sema.resolveInst(extra.layout); |
| 19833 | const layout_coerced = try sema.coerce(block, container_layout_ty, layout_uncoerced, layout_src); | 20081 | const layout_coerced = try sema.coerce(block, container_layout_ty, layout_uncoerced, layout_src); |
| ... | @@ -20107,7 +20355,7 @@ fn zirReifyUnion( | ... | @@ -20107,7 +20355,7 @@ fn zirReifyUnion( |
| 20107 | }; | 20355 | }; |
| 20108 | | 20356 | |
| 20109 | const container_layout_ty = try sema.getStdLangType(layout_src, .@"Type.ContainerLayout"); | 20357 | const container_layout_ty = try sema.getStdLangType(layout_src, .@"Type.ContainerLayout"); |
| 20110 | const single_field_attrs_ty = try sema.getStdLangType(field_attrs_src, .@"Type.UnionField.Attributes"); | 20358 | const single_field_attrs_ty = try sema.getStdLangType(field_attrs_src, .@"Type.Union.FieldAttributes"); |
| 20111 | | 20359 | |
| 20112 | const layout_uncoerced = sema.resolveInst(extra.layout); | 20360 | const layout_uncoerced = sema.resolveInst(extra.layout); |
| 20113 | const layout_coerced = try sema.coerce(block, container_layout_ty, layout_uncoerced, layout_src); | 20361 | const layout_coerced = try sema.coerce(block, container_layout_ty, layout_uncoerced, layout_src); |
Krzysztof Wolicki <der.teufel.mail@gmail.com> 2026-04-30 14:48:37+02:00
Matthew Lugg <mlugg@mlugg.co.uk> 2026-05-27 09:19:51+01:00
Commit is signed but in an unrecognized format.