| ... | ... | @@ -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 | 2836 | fn zirTupleDecl( |
| 2826 | 2837 | sema: *Sema, |
| 2827 | 2838 | block: *Block, |
| ... | ... | @@ -15988,13 +15999,19 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 15988 | 15999 | |
| 15989 | 16000 | .@"fn" => { |
| 15990 | 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 | 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 | 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 | 16015 | const param_ty = func_ty_info.param_types.get(ip)[param_index]; |
| 15999 | 16016 | const is_generic = param_ty == .generic_poison_type; |
| 16000 | 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 | 16028 | .val = if (is_generic) .none else param_ty, |
| 16012 | 16029 | } }); |
| 16013 | 16030 | |
| 16014 | | const param_fields = .{ |
| 16015 | | // is_generic: bool, |
| 16016 | | Value.makeBool(is_generic).toIntern(), |
| 16017 | | // is_noalias: bool, |
| 16031 | const param_attrs_fields = .{ |
| 16032 | // @"noalias": bool, |
| 16018 | 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 | 16041 | const new_decl_ty = try pt.arrayType(.{ |
| 16027 | | .len = param_vals.len, |
| 16028 | | .child = param_info_ty.toIntern(), |
| 16042 | .len = param_type_vals.len, |
| 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 | 16046 | const slice_ty = (try pt.ptrType(.{ |
| 16032 | | .child = param_info_ty.toIntern(), |
| 16047 | .child = try pt.intern(.{ .opt_type = .type_type }), |
| 16033 | 16048 | .flags = .{ |
| 16034 | 16049 | .size = .slice, |
| 16035 | 16050 | .is_const = true, |
| ... | ... | @@ -16046,7 +16061,34 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16046 | 16061 | } }, |
| 16047 | 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 | 16117 | error.OutOfMemory => |e| return e, |
| 16076 | 16118 | }; |
| 16077 | 16119 | |
| 16078 | | const field_values: [5]InternPool.Index = .{ |
| 16079 | | // calling_convention: CallingConvention, |
| 16120 | const fn_attrs_values = .{ |
| 16121 | // @"callconv": CallingConvention = .auto, |
| 16080 | 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 | 16130 | // is_generic: bool, |
| 16082 | 16131 | Value.makeBool(func_is_generic).toIntern(), |
| 16083 | | // is_var_args: bool, |
| 16084 | | Value.makeBool(func_ty_info.is_var_args).toIntern(), |
| 16085 | 16132 | // return_type: ?type, |
| 16086 | 16133 | ret_ty_opt, |
| 16087 | | // args: []const Fn.Param, |
| 16088 | | args_val, |
| 16134 | |
| 16135 | // param_types: []const ?type, |
| 16136 | param_types_val, |
| 16137 | // param_attrs: []const ParamAttributes, |
| 16138 | param_attrs_val, |
| 16089 | 16139 | }; |
| 16090 | 16140 | return Air.internedToRef((try pt.internUnion(.{ |
| 16091 | 16141 | .ty = type_info_ty.toIntern(), |
| ... | ... | @@ -16139,23 +16189,34 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16139 | 16189 | const addrspace_ty = try sema.getStdLangType(src, .AddressSpace); |
| 16140 | 16190 | const pointer_ty = try sema.getStdLangType(src, .@"Type.Pointer"); |
| 16141 | 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 = .{ |
| 16144 | | // size: Size, |
| 16145 | | (try pt.enumValueFieldIndex(ptr_size_ty, @intFromEnum(info.flags.size))).toIntern(), |
| 16146 | | // is_const: bool, |
| 16194 | const opt_addrspace_val = try pt.intern(.{ .opt = .{ |
| 16195 | .ty = (try pt.optionalType(addrspace_ty.toIntern())).toIntern(), |
| 16196 | .val = (try sema.uninterpretStdLangType(info.flags.address_space, addrspace_ty)).toIntern(), |
| 16197 | } }); |
| 16198 | |
| 16199 | const attributes = .{ |
| 16200 | // @"const": bool = false, |
| 16147 | 16201 | Value.makeBool(info.flags.is_const).toIntern(), |
| 16148 | | // is_volatile: bool, |
| 16202 | // @"volatile": bool = false, |
| 16149 | 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 | 16209 | alignment_val.toIntern(), |
| 16152 | | // address_space: AddressSpace |
| 16153 | | (try pt.enumValueFieldIndex(addrspace_ty, @intFromEnum(info.flags.address_space))).toIntern(), |
| 16210 | }; |
| 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 | 16217 | // child: type, |
| 16155 | 16218 | info.child, |
| 16156 | | // is_allowzero: bool, |
| 16157 | | Value.makeBool(info.flags.is_allowzero).toIntern(), |
| 16158 | | // sentinel: ?*const anyopaque, |
| 16219 | // sentinel_ptr: ?*const anyopaque, |
| 16159 | 16220 | (try sema.optRefValue(switch (info.sentinel) { |
| 16160 | 16221 | .none => null, |
| 16161 | 16222 | else => Value.fromInterned(info.sentinel), |
| ... | ... | @@ -16215,8 +16276,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16215 | 16276 | }))); |
| 16216 | 16277 | }, |
| 16217 | 16278 | .error_set => { |
| 16218 | | // Get the Error type |
| 16219 | | const error_field_ty = try sema.getStdLangType(src, .@"Type.Error"); |
| 16279 | const error_set_ty = try sema.getStdLangType(src, .@"Type.ErrorSet"); |
| 16220 | 16280 | |
| 16221 | 16281 | // Build our list of Error values |
| 16222 | 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 | 16313 | } }); |
| 16254 | 16314 | }; |
| 16255 | 16315 | |
| 16256 | | const error_field_fields = .{ |
| 16257 | | // name: [:0]const u8, |
| 16258 | | error_name_val, |
| 16259 | | }; |
| 16260 | | field_val.* = (try pt.aggregateValue(error_field_ty, &error_field_fields)).toIntern(); |
| 16316 | field_val.* = error_name_val; |
| 16261 | 16317 | } |
| 16262 | 16318 | |
| 16263 | 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 | 16324 | const slice_errors_ty = try pt.ptrType(.{ |
| 16269 | | .child = error_field_ty.toIntern(), |
| 16325 | .child = .slice_const_u8_sentinel_0_type, |
| 16270 | 16326 | .flags = .{ |
| 16271 | 16327 | .size = .slice, |
| 16272 | 16328 | .is_const = true, |
| ... | ... | @@ -16276,7 +16332,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16276 | 16332 | const errors_payload_val: InternPool.Index = if (error_field_vals) |vals| v: { |
| 16277 | 16333 | const array_errors_ty = try pt.arrayType(.{ |
| 16278 | 16334 | .len = vals.len, |
| 16279 | | .child = error_field_ty.toIntern(), |
| 16335 | .child = .slice_const_u8_sentinel_0_type, |
| 16280 | 16336 | }); |
| 16281 | 16337 | const new_decl_val = (try pt.aggregateValue(array_errors_ty, vals)).toIntern(); |
| 16282 | 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 | 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 | 16362 | // Construct Type{ .error_set = errors_val } |
| 16302 | 16363 | return Air.internedToRef((try pt.internUnion(.{ |
| 16303 | 16364 | .ty = type_info_ty.toIntern(), |
| 16304 | 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 | 16369 | .error_union => { |
| ... | ... | @@ -16322,12 +16383,20 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16322 | 16383 | }, |
| 16323 | 16384 | .@"enum" => { |
| 16324 | 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); |
| 16330 | | for (enum_field_vals, 0..) |*field_val, tag_index| { |
| 16389 | const enum_mode_tag: std.builtin.Type.Enum.Mode = if (enum_obj.nonexhaustive) .nonexhaustive else .exhaustive; |
| 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 | 16400 | const value_val = if (enum_obj.field_values.len > 0) |
| 16332 | 16401 | try ip.getCoercedInts( |
| 16333 | 16402 | gpa, |
| ... | ... | @@ -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 = .{ |
| 16370 | | // name: [:0]const u8, |
| 16371 | | name_val, |
| 16372 | | // value: comptime_int, |
| 16373 | | value_val, |
| 16374 | | }; |
| 16375 | | field_val.* = (try pt.aggregateValue(enum_field_ty, &enum_field_fields)).toIntern(); |
| 16438 | field_name_val.* = name_val; |
| 16439 | field_value_val.* = value_val; |
| 16376 | 16440 | } |
| 16377 | 16441 | |
| 16378 | | const fields_val = v: { |
| 16379 | | const fields_array_ty = try pt.arrayType(.{ |
| 16380 | | .len = enum_field_vals.len, |
| 16381 | | .child = enum_field_ty.toIntern(), |
| 16442 | const fields_names_val = v: { |
| 16443 | const fields_names_array_ty = try pt.arrayType(.{ |
| 16444 | .len = enum_field_name_vals.len, |
| 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 | 16448 | const slice_ty = (try pt.ptrType(.{ |
| 16385 | | .child = enum_field_ty.toIntern(), |
| 16449 | .child = .slice_const_u8_sentinel_0_type, |
| 16386 | 16450 | .flags = .{ |
| 16387 | 16451 | .size = .slice, |
| 16388 | 16452 | .is_const = true, |
| ... | ... | @@ -16399,23 +16463,55 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16399 | 16463 | } }, |
| 16400 | 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 | 16500 | const type_enum_ty = try sema.getStdLangType(src, .@"Type.Enum"); |
| 16409 | 16501 | |
| 16410 | 16502 | const field_values = .{ |
| 16411 | 16503 | // tag_type: type, |
| 16412 | 16504 | ip.loadEnumType(ty.toIntern()).int_tag_type, |
| 16413 | | // fields: []const EnumField, |
| 16414 | | fields_val, |
| 16415 | | // decls: []const Declaration, |
| 16416 | | decls_val, |
| 16417 | | // is_exhaustive: bool, |
| 16418 | | is_exhaustive.toIntern(), |
| 16505 | // mode: Mode |
| 16506 | enum_mode.toIntern(), |
| 16507 | |
| 16508 | // field_names: []const [:0]const u8, |
| 16509 | fields_names_val, |
| 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 | 16516 | return Air.internedToRef((try pt.internUnion(.{ |
| 16421 | 16517 | .ty = type_info_ty.toIntern(), |
| ... | ... | @@ -16425,16 +16521,26 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16425 | 16521 | }, |
| 16426 | 16522 | .@"union" => { |
| 16427 | 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 | 16526 | const union_obj = ip.loadUnionType(ty.toIntern()); |
| 16431 | 16527 | const enum_obj = ip.loadEnumType(union_obj.enum_tag_type); |
| 16432 | 16528 | const layout = union_obj.layout; |
| 16433 | 16529 | |
| 16434 | | const union_field_vals = try gpa.alloc(InternPool.Index, enum_obj.field_names.len); |
| 16435 | | defer gpa.free(union_field_vals); |
| 16436 | | |
| 16437 | | for (union_field_vals, 0..) |*field_val, field_index| { |
| 16530 | const union_field_names = try gpa.alloc(InternPool.Index, enum_obj.field_names.len); |
| 16531 | defer gpa.free(union_field_names); |
| 16532 | const union_field_attrs = try gpa.alloc(InternPool.Index, enum_obj.field_names.len); |
| 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 | 16544 | const name_val = v: { |
| 16439 | 16545 | const field_name = enum_obj.field_names.get(ip)[field_index]; |
| 16440 | 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 | 16567 | } }); |
| 16462 | 16568 | }; |
| 16463 | 16569 | |
| 16464 | | const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_index]); |
| 16465 | | |
| 16466 | 16570 | const alignment_ty = try pt.optionalType(.usize_type); |
| 16467 | 16571 | const alignment_val: Value = val: { |
| 16468 | 16572 | const a: Alignment = switch (layout) { |
| ... | ... | @@ -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 = .{ |
| 16483 | | // name: [:0]const u8, |
| 16484 | | name_val, |
| 16485 | | // type: type, |
| 16486 | | field_ty.toIntern(), |
| 16586 | field_name_val.* = name_val; |
| 16587 | const union_field_attr = .{ |
| 16487 | 16588 | // alignment: ?usize, |
| 16488 | 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 | 16625 | const array_fields_ty = try pt.arrayType(.{ |
| 16495 | | .len = union_field_vals.len, |
| 16496 | | .child = union_field_ty.toIntern(), |
| 16626 | .len = union_field_types.len, |
| 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 | 16630 | const slice_ty = (try pt.ptrType(.{ |
| 16500 | | .child = union_field_ty.toIntern(), |
| 16631 | .child = .type_type, |
| 16501 | 16632 | .flags = .{ |
| 16502 | 16633 | .size = .slice, |
| 16503 | 16634 | .is_const = true, |
| ... | ... | @@ -16514,11 +16645,38 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16514 | 16645 | } }, |
| 16515 | 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 | 16681 | const enum_tag_ty_val = try pt.intern(.{ .opt = .{ |
| 16524 | 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 | 16685 | |
| 16528 | 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 | 16696 | const field_values = .{ |
| 16531 | 16697 | // layout: ContainerLayout, |
| 16532 | 16698 | (try pt.enumValueFieldIndex(container_layout_ty, @intFromEnum(layout))).toIntern(), |
| 16533 | 16699 | |
| 16534 | 16700 | // tag_type: ?type, |
| 16535 | 16701 | enum_tag_ty_val, |
| 16536 | | // fields: []const UnionField, |
| 16537 | | fields_val, |
| 16538 | | // decls: []const Declaration, |
| 16539 | | decls_val, |
| 16702 | // backing_integer: ?type, |
| 16703 | backing_integer_val, |
| 16704 | |
| 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 | 16715 | return Air.internedToRef((try pt.internUnion(.{ |
| 16542 | 16716 | .ty = type_info_ty.toIntern(), |
| ... | ... | @@ -16546,16 +16720,26 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16546 | 16720 | }, |
| 16547 | 16721 | .@"struct" => { |
| 16548 | 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 = &.{}; |
| 16552 | | defer gpa.free(struct_field_vals); |
| 16725 | var struct_field_name_vals: []InternPool.Index = &.{}; |
| 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 | 16729 | fv: { |
| 16554 | 16730 | const struct_type = switch (ip.indexToKey(ty.toIntern())) { |
| 16555 | 16731 | .tuple_type => |tuple_type| { |
| 16556 | | struct_field_vals = try gpa.alloc(InternPool.Index, tuple_type.types.len); |
| 16557 | | for (struct_field_vals, 0..) |*struct_field_val, field_index| { |
| 16558 | | const field_ty = tuple_type.types.get(ip)[field_index]; |
| 16732 | struct_field_name_vals = try gpa.alloc(InternPool.Index, tuple_type.types.len); |
| 16733 | struct_field_attr_vals = try gpa.alloc(InternPool.Index, tuple_type.types.len); |
| 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 | 16743 | const field_val = tuple_type.values.get(ip)[field_index]; |
| 16560 | 16744 | const name_val = v: { |
| 16561 | 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 | 16771 | const opt_default_val = if (is_comptime) Value.fromInterned(field_val) else null; |
| 16588 | 16772 | const default_val_ptr = try sema.optRefValue(opt_default_val); |
| 16589 | 16773 | |
| 16590 | | const struct_field_fields = .{ |
| 16591 | | // name: [:0]const u8, |
| 16592 | | name_val, |
| 16593 | | // type: type, |
| 16594 | | field_ty, |
| 16595 | | // default_value: ?*const anyopaque, |
| 16596 | | default_val_ptr.toIntern(), |
| 16597 | | // is_comptime: bool, |
| 16774 | const struct_field_attr_fields = .{ |
| 16775 | // @"comptime": bool, |
| 16598 | 16776 | Value.makeBool(is_comptime).toIntern(), |
| 16599 | | // alignment: ?usize, |
| 16777 | // @"align": ?usize, |
| 16600 | 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 | 16786 | break :fv; |
| 16605 | 16787 | }, |
| ... | ... | @@ -16607,12 +16789,20 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16607 | 16789 | else => unreachable, |
| 16608 | 16790 | }; |
| 16609 | 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); |
| 16611 | | |
| 16612 | | for (struct_field_vals, 0..) |*field_val, field_index| { |
| 16792 | struct_field_name_vals = try gpa.alloc(InternPool.Index, struct_type.field_types.len); |
| 16793 | struct_field_attr_vals = try gpa.alloc(InternPool.Index, struct_type.field_types.len); |
| 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 | 16804 | const field_name = struct_type.field_names.get(ip)[field_index]; |
| 16614 | 16805 | const field_name_len = field_name.length(ip); |
| 16615 | | const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[field_index]); |
| 16616 | 16806 | const field_default: InternPool.Index = if (struct_type.field_defaults.len > 0) d: { |
| 16617 | 16807 | break :d struct_type.field_defaults.get(ip)[field_index]; |
| 16618 | 16808 | } else .none; |
| ... | ... | @@ -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 = .{ |
| 16664 | | // name: [:0]const u8, |
| 16665 | | name_val, |
| 16666 | | // type: type, |
| 16667 | | field_ty.toIntern(), |
| 16668 | | // default_value: ?*const anyopaque, |
| 16669 | | default_val_ptr.toIntern(), |
| 16670 | | // is_comptime: bool, |
| 16853 | const struct_field_attr_fields = .{ |
| 16854 | // @"comptime": bool, |
| 16671 | 16855 | Value.makeBool(field_is_comptime).toIntern(), |
| 16672 | | // alignment: ?usize, |
| 16856 | // @"align": ?usize, |
| 16673 | 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 | 16903 | const array_fields_ty = try pt.arrayType(.{ |
| 16681 | | .len = struct_field_vals.len, |
| 16682 | | .child = struct_field_ty.toIntern(), |
| 16904 | .len = struct_field_type_vals.len, |
| 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 | 16908 | const slice_ty = (try pt.ptrType(.{ |
| 16686 | | .child = struct_field_ty.toIntern(), |
| 16909 | .child = .type_type, |
| 16687 | 16910 | .flags = .{ |
| 16688 | 16911 | .size = .slice, |
| 16689 | 16912 | .is_const = true, |
| ... | ... | @@ -16700,11 +16923,38 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16700 | 16923 | } }, |
| 16701 | 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 | 16959 | const backing_integer_val = try pt.intern(.{ .opt = .{ |
| 16710 | 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 | 16969 | const layout = ty.containerLayout(zcu); |
| 16720 | 16970 | |
| 16721 | 16971 | const field_values = [_]InternPool.Index{ |
| 16972 | // is_tuple: bool, |
| 16973 | Value.makeBool(ty.isTuple(zcu)).toIntern(), |
| 16722 | 16974 | // layout: ContainerLayout, |
| 16723 | 16975 | (try pt.enumValueFieldIndex(container_layout_ty, @intFromEnum(layout))).toIntern(), |
| 16724 | 16976 | // backing_integer: ?type, |
| 16725 | 16977 | backing_integer_val, |
| 16726 | | // fields: []const StructField, |
| 16727 | | fields_val, |
| 16728 | | // decls: []const Declaration, |
| 16729 | | decls_val, |
| 16730 | | // is_tuple: bool, |
| 16731 | | Value.makeBool(ty.isTuple(zcu)).toIntern(), |
| 16978 | |
| 16979 | // field_names: []const [:0]const u8, |
| 16980 | field_names_val, |
| 16981 | // field_types: []const type, |
| 16982 | field_types_val, |
| 16983 | // field_attrs: []const FieldAttributes, |
| 16984 | field_attrs_val, |
| 16985 | |
| 16986 | // decl_names: []const [:0]const u8, |
| 16987 | decl_names_val, |
| 16732 | 16988 | }; |
| 16733 | 16989 | return Air.internedToRef((try pt.internUnion(.{ |
| 16734 | 16990 | .ty = type_info_ty.toIntern(), |
| ... | ... | @@ -16739,11 +16995,11 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16739 | 16995 | .@"opaque" => { |
| 16740 | 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 | 17000 | const field_values = .{ |
| 16745 | | // decls: []const Declaration, |
| 16746 | | decls_val, |
| 17001 | // decl_names: []const [:0]const u8, |
| 17002 | decl_names_val, |
| 16747 | 17003 | }; |
| 16748 | 17004 | return Air.internedToRef((try pt.internUnion(.{ |
| 16749 | 17005 | .ty = type_info_ty.toIntern(), |
| ... | ... | @@ -16758,30 +17014,27 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 16758 | 17014 | |
| 16759 | 17015 | fn typeInfoDecls( |
| 16760 | 17016 | sema: *Sema, |
| 16761 | | src: LazySrcLoc, |
| 16762 | 17017 | opt_namespace: InternPool.OptionalNamespaceIndex, |
| 16763 | 17018 | ) CompileError!InternPool.Index { |
| 16764 | 17019 | const pt = sema.pt; |
| 16765 | 17020 | const zcu = pt.zcu; |
| 16766 | 17021 | const gpa = sema.gpa; |
| 16767 | 17022 | |
| 16768 | | const declaration_ty = try sema.getStdLangType(src, .@"Type.Declaration"); |
| 16769 | | |
| 16770 | 17023 | var decl_vals = std.array_list.Managed(InternPool.Index).init(gpa); |
| 16771 | 17024 | defer decl_vals.deinit(); |
| 16772 | 17025 | |
| 16773 | 17026 | var seen_namespaces = std.AutoHashMap(*Namespace, void).init(gpa); |
| 16774 | 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 | 17031 | const array_decl_ty = try pt.arrayType(.{ |
| 16779 | 17032 | .len = decl_vals.items.len, |
| 16780 | | .child = declaration_ty.toIntern(), |
| 17033 | .child = .slice_const_u8_sentinel_0_type, |
| 16781 | 17034 | }); |
| 16782 | 17035 | const new_decl_val = (try pt.aggregateValue(array_decl_ty, decl_vals.items)).toIntern(); |
| 16783 | 17036 | const slice_ty = (try pt.ptrType(.{ |
| 16784 | | .child = declaration_ty.toIntern(), |
| 17037 | .child = .slice_const_u8_sentinel_0_type, |
| 16785 | 17038 | .flags = .{ |
| 16786 | 17039 | .size = .slice, |
| 16787 | 17040 | .is_const = true, |
| ... | ... | @@ -16805,7 +17058,6 @@ fn typeInfoDecls( |
| 16805 | 17058 | fn typeInfoNamespaceDecls( |
| 16806 | 17059 | sema: *Sema, |
| 16807 | 17060 | opt_namespace_index: InternPool.OptionalNamespaceIndex, |
| 16808 | | declaration_ty: Type, |
| 16809 | 17061 | decl_vals: *std.array_list.Managed(InternPool.Index), |
| 16810 | 17062 | seen_namespaces: *std.AutoHashMap(*Namespace, void), |
| 16811 | 17063 | ) !void { |
| ... | ... | @@ -16850,11 +17102,7 @@ fn typeInfoNamespaceDecls( |
| 16850 | 17102 | }, |
| 16851 | 17103 | }); |
| 16852 | 17104 | }; |
| 16853 | | const fields = [_]InternPool.Index{ |
| 16854 | | // name: [:0]const u8, |
| 16855 | | name_val, |
| 16856 | | }; |
| 16857 | | try decl_vals.append((try pt.aggregateValue(declaration_ty, &fields)).toIntern()); |
| 17105 | try decl_vals.append(name_val); |
| 16858 | 17106 | } |
| 16859 | 17107 | } |
| 16860 | 17108 | |
| ... | ... | @@ -19470,11 +19718,11 @@ fn zirReifySliceArgTy( |
| 19470 | 19718 | |
| 19471 | 19719 | const comptime_reason: std.zig.SimpleComptimeReason, const in_scalar_ty: Type, const out_scalar_ty: Type = switch (info) { |
| 19472 | 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 | 19722 | .string_to_struct_field_type => .{ .struct_field_types, .slice_const_u8, .type }, |
| 19475 | 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") }, |
| 19477 | | .string_to_union_field_attrs => .{ .union_field_attrs, .slice_const_u8, try sema.getStdLangType(src, .@"Type.UnionField.Attributes") }, |
| 19724 | .string_to_struct_field_attrs => .{ .struct_field_attrs, .slice_const_u8, try sema.getStdLangType(src, .@"Type.Struct.FieldAttributes") }, |
| 19725 | .string_to_union_field_attrs => .{ .union_field_attrs, .slice_const_u8, try sema.getStdLangType(src, .@"Type.Union.FieldAttributes") }, |
| 19478 | 19726 | // zig fmt: on |
| 19479 | 19727 | }; |
| 19480 | 19728 | |
| ... | ... | @@ -19688,7 +19936,7 @@ fn zirReifyFn( |
| 19688 | 19936 | const ret_ty_src = block.builtinCallArgSrc(extra.node, 2); |
| 19689 | 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 | 19940 | const fn_attrs_ty = try sema.getStdLangType(fn_attrs_src, .@"Type.Fn.Attributes"); |
| 19693 | 19941 | |
| 19694 | 19942 | const param_types_uncoerced = sema.resolveInst(extra.param_types); |
| ... | ... | @@ -19827,7 +20075,7 @@ fn zirReifyStruct( |
| 19827 | 20075 | }; |
| 19828 | 20076 | |
| 19829 | 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 | 20080 | const layout_uncoerced = sema.resolveInst(extra.layout); |
| 19833 | 20081 | const layout_coerced = try sema.coerce(block, container_layout_ty, layout_uncoerced, layout_src); |
| ... | ... | @@ -20107,7 +20355,7 @@ fn zirReifyUnion( |
| 20107 | 20355 | }; |
| 20108 | 20356 | |
| 20109 | 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 | 20360 | const layout_uncoerced = sema.resolveInst(extra.layout); |
| 20113 | 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.