authorgravatar for mlugg@mlugg.co.ukMatthew Lugg <mlugg@mlugg.co.uk> 2024-08-04 21:41:53+01:00
committergravatar for mlugg@mlugg.co.ukMatthew Lugg <mlugg@mlugg.co.uk> 2024-08-11 07:30:21+01:00
log153e7d6235a7d74d0c02d51f84edc5c06ab7469d
treec4b372662b0253de33483225d17a8a79c735ada5
parent548a087fafeda5b07d2237d5137906b8d07da699
signaturelock-open Commit is signed but in an unrecognized format.

frontend: give all container types namespaces

Eliding the namespace when a container type has no decls was an experiment in saving memory, but it ended up causing more trouble than it was worth in various places. So, take the small memory hit for reified types, and just give every container type a namespace.

5 files changed, 156 insertions(+), 205 deletions(-)

src/InternPool.zig+55-76
......@@ -2885,7 +2885,7 @@ pub const LoadedUnionType = struct {
28852885 /// The `Cau` within which type resolution occurs.
28862886 cau: Cau.Index,
28872887 /// Represents the declarations inside this union.
2888 namespace: OptionalNamespaceIndex,
2888 namespace: NamespaceIndex,
28892889 /// The enum tag type.
28902890 enum_tag_ty: Index,
28912891 /// List of field types in declaration order.
......@@ -3219,7 +3219,7 @@ pub const LoadedStructType = struct {
32193219 name: NullTerminatedString,
32203220 /// The `Cau` within which type resolution occurs. `none` when the struct is `@TypeOf(.{})`.
32213221 cau: Cau.Index.Optional,
3222 /// `none` when the struct has no declarations.
3222 /// `none` when the struct is `@TypeOf(.{})`.
32233223 namespace: OptionalNamespaceIndex,
32243224 /// Index of the `struct_decl` or `reify` ZIR instruction.
32253225 /// Only `none` when the struct is `@TypeOf(.{})`.
......@@ -3834,6 +3834,7 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
38343834 };
38353835 const name: NullTerminatedString = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "name").?]);
38363836 const cau: Cau.Index = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "cau").?]);
3837 const namespace: NamespaceIndex = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "namespace").?]);
38373838 const zir_index: TrackedInst.Index = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "zir_index").?]);
38383839 const fields_len = extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "fields_len").?];
38393840 const flags: Tag.TypeStruct.Flags = @bitCast(@atomicLoad(u32, &extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "flags").?], .unordered));
......@@ -3878,11 +3879,6 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
38783879 extra_index += fields_len;
38793880 break :i inits;
38803881 } else Index.Slice.empty;
3881 const namespace: OptionalNamespaceIndex = if (flags.has_namespace) n: {
3882 const n: NamespaceIndex = @enumFromInt(extra_list.view().items(.@"0")[extra_index]);
3883 extra_index += 1;
3884 break :n n.toOptional();
3885 } else .none;
38863882 const aligns: Alignment.Slice = if (flags.any_aligned_fields) a: {
38873883 const a: Alignment.Slice = .{
38883884 .tid = unwrapped_index.tid,
......@@ -3925,7 +3921,7 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
39253921 .extra_index = item.data,
39263922 .name = name,
39273923 .cau = cau.toOptional(),
3928 .namespace = namespace,
3924 .namespace = namespace.toOptional(),
39293925 .zir_index = zir_index.toOptional(),
39303926 .layout = if (flags.is_extern) .@"extern" else .auto,
39313927 .field_names = names,
......@@ -3944,7 +3940,7 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
39443940 const cau: Cau.Index = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "cau").?]);
39453941 const zir_index: TrackedInst.Index = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "zir_index").?]);
39463942 const fields_len = extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "fields_len").?];
3947 const namespace: OptionalNamespaceIndex = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "namespace").?]);
3943 const namespace: NamespaceIndex = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "namespace").?]);
39483944 const names_map: MapIndex = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "names_map").?]);
39493945 const flags: Tag.TypeStructPacked.Flags = @bitCast(@atomicLoad(u32, &extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "flags").?], .unordered));
39503946 var extra_index = item.data + @as(u32, @typeInfo(Tag.TypeStructPacked).Struct.fields.len);
......@@ -3989,7 +3985,7 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
39893985 .extra_index = item.data,
39903986 .name = name,
39913987 .cau = cau.toOptional(),
3992 .namespace = namespace,
3988 .namespace = namespace.toOptional(),
39933989 .zir_index = zir_index.toOptional(),
39943990 .layout = .@"packed",
39953991 .field_names = field_names,
......@@ -4015,7 +4011,7 @@ const LoadedEnumType = struct {
40154011 /// `null` if this is a generated tag type.
40164012 cau: Cau.Index.Optional,
40174013 /// Represents the declarations inside this enum.
4018 namespace: OptionalNamespaceIndex,
4014 namespace: NamespaceIndex,
40194015 /// An integer type which is used for the numerical value of the enum.
40204016 /// This field is present regardless of whether the enum has an
40214017 /// explicitly provided tag type or auto-numbered.
......@@ -4172,7 +4168,7 @@ pub fn loadEnumType(ip: *const InternPool, index: Index) LoadedEnumType {
41724168/// Note that this type doubles as the payload for `Tag.type_opaque`.
41734169pub const LoadedOpaqueType = struct {
41744170 /// Contains the declarations inside this opaque.
4175 namespace: OptionalNamespaceIndex,
4171 namespace: NamespaceIndex,
41764172 // TODO: the non-fqn will be needed by the new dwarf structure
41774173 /// The name of this opaque type.
41784174 name: NullTerminatedString,
......@@ -5324,7 +5320,7 @@ pub const Tag = enum(u8) {
53245320 /// Only valid after .have_layout
53255321 padding: u32,
53265322 cau: Cau.Index,
5327 namespace: OptionalNamespaceIndex,
5323 namespace: NamespaceIndex,
53285324 /// The enum that provides the list of field names and values.
53295325 tag_ty: Index,
53305326 zir_index: TrackedInst.Index,
......@@ -5357,7 +5353,7 @@ pub const Tag = enum(u8) {
53575353 cau: Cau.Index,
53585354 zir_index: TrackedInst.Index,
53595355 fields_len: u32,
5360 namespace: OptionalNamespaceIndex,
5356 namespace: NamespaceIndex,
53615357 backing_int_ty: Index,
53625358 names_map: MapIndex,
53635359 flags: Flags,
......@@ -5396,19 +5392,18 @@ pub const Tag = enum(u8) {
53965392 /// name: NullTerminatedString // for each field in declared order
53975393 /// 5. if any_default_inits:
53985394 /// init: Index // for each field in declared order
5399 /// 6. if has_namespace:
5400 /// namespace: NamespaceIndex
5401 /// 7. if any_aligned_fields:
5395 /// 6. if any_aligned_fields:
54025396 /// align: Alignment // for each field in declared order
5403 /// 8. if any_comptime_fields:
5397 /// 7. if any_comptime_fields:
54045398 /// field_is_comptime_bits: u32 // minimal number of u32s needed, LSB is field 0
5405 /// 9. if not is_extern:
5399 /// 8. if not is_extern:
54065400 /// field_index: RuntimeOrder // for each field in runtime order
5407 /// 10. field_offset: u32 // for each field in declared order, undef until layout_resolved
5401 /// 9. field_offset: u32 // for each field in declared order, undef until layout_resolved
54085402 pub const TypeStruct = struct {
54095403 name: NullTerminatedString,
54105404 cau: Cau.Index,
54115405 zir_index: TrackedInst.Index,
5406 namespace: NamespaceIndex,
54125407 fields_len: u32,
54135408 flags: Flags,
54145409 size: u32,
......@@ -5421,7 +5416,6 @@ pub const Tag = enum(u8) {
54215416 is_tuple: bool = false,
54225417 assumed_runtime_bits: bool = false,
54235418 assumed_pointer_aligned: bool = false,
5424 has_namespace: bool = false,
54255419 any_comptime_fields: bool = false,
54265420 any_default_inits: bool = false,
54275421 any_aligned_fields: bool = false,
......@@ -5444,7 +5438,7 @@ pub const Tag = enum(u8) {
54445438 // which `layout_resolved` does not ensure.
54455439 fully_resolved: bool = false,
54465440 is_reified: bool = false,
5447 _: u6 = 0,
5441 _: u7 = 0,
54485442 };
54495443 };
54505444
......@@ -5453,7 +5447,7 @@ pub const Tag = enum(u8) {
54535447 pub const TypeOpaque = struct {
54545448 name: NullTerminatedString,
54555449 /// Contains the declarations inside this opaque.
5456 namespace: OptionalNamespaceIndex,
5450 namespace: NamespaceIndex,
54575451 /// The index of the `opaque_decl` instruction.
54585452 zir_index: TrackedInst.Index,
54595453 /// `std.math.maxInt(u32)` indicates this type is reified.
......@@ -5762,8 +5756,7 @@ pub const EnumExplicit = struct {
57625756 name: NullTerminatedString,
57635757 /// `std.math.maxInt(u32)` indicates this type is reified.
57645758 captures_len: u32,
5765 /// This may be `none` if there are no declarations.
5766 namespace: OptionalNamespaceIndex,
5759 namespace: NamespaceIndex,
57675760 /// An integer type which is used for the numerical value of the enum, which
57685761 /// has been explicitly provided by the enum declaration.
57695762 int_tag_type: Index,
......@@ -5789,8 +5782,7 @@ pub const EnumAuto = struct {
57895782 name: NullTerminatedString,
57905783 /// `std.math.maxInt(u32)` indicates this type is reified.
57915784 captures_len: u32,
5792 /// This may be `none` if there are no declarations.
5793 namespace: OptionalNamespaceIndex,
5785 namespace: NamespaceIndex,
57945786 /// An integer type which is used for the numerical value of the enum, which
57955787 /// was inferred by Zig based on the number of tags.
57965788 int_tag_type: Index,
......@@ -7854,7 +7846,6 @@ pub const UnionTypeInit = struct {
78547846 assumed_pointer_aligned: bool,
78557847 alignment: Alignment,
78567848 },
7857 has_namespace: bool,
78587849 fields_len: u32,
78597850 enum_tag_ty: Index,
78607851 /// May have length 0 which leaves the values unset until later.
......@@ -7930,7 +7921,7 @@ pub fn getUnionType(
79307921 .padding = std.math.maxInt(u32),
79317922 .name = undefined, // set by `finish`
79327923 .cau = undefined, // set by `finish`
7933 .namespace = .none, // set by `finish`
7924 .namespace = undefined, // set by `finish`
79347925 .tag_ty = ini.enum_tag_ty,
79357926 .zir_index = switch (ini.key) {
79367927 inline else => |x| x.zir_index,
......@@ -7978,10 +7969,7 @@ pub fn getUnionType(
79787969 .index = gop.put(),
79797970 .type_name_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeUnion, "name").?,
79807971 .cau_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeUnion, "cau").?,
7981 .namespace_extra_index = if (ini.has_namespace)
7982 extra_index + std.meta.fieldIndex(Tag.TypeUnion, "namespace").?
7983 else
7984 null,
7972 .namespace_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeUnion, "namespace").?,
79857973 } };
79867974}
79877975
......@@ -7990,7 +7978,7 @@ pub const WipNamespaceType = struct {
79907978 index: Index,
79917979 type_name_extra_index: u32,
79927980 cau_extra_index: ?u32,
7993 namespace_extra_index: ?u32,
7981 namespace_extra_index: u32,
79947982
79957983 pub fn setName(
79967984 wip: WipNamespaceType,
......@@ -8006,7 +7994,7 @@ pub const WipNamespaceType = struct {
80067994 wip: WipNamespaceType,
80077995 ip: *InternPool,
80087996 analysis_owner: Cau.Index.Optional,
8009 namespace: OptionalNamespaceIndex,
7997 namespace: NamespaceIndex,
80107998 ) Index {
80117999 const extra = ip.getLocalShared(wip.tid).extra.acquire();
80128000 const extra_items = extra.view().items(.@"0");
......@@ -8017,11 +8005,7 @@ pub const WipNamespaceType = struct {
80178005 assert(analysis_owner == .none);
80188006 }
80198007
8020 if (wip.namespace_extra_index) |i| {
8021 extra_items[i] = @intFromEnum(namespace.unwrap().?);
8022 } else {
8023 assert(namespace == .none);
8024 }
8008 extra_items[wip.namespace_extra_index] = @intFromEnum(namespace);
80258009
80268010 return wip.index;
80278011 }
......@@ -8046,7 +8030,6 @@ pub const StructTypeInit = struct {
80468030 any_default_inits: bool,
80478031 inits_resolved: bool,
80488032 any_aligned_fields: bool,
8049 has_namespace: bool,
80508033 key: union(enum) {
80518034 declared: struct {
80528035 zir_index: TrackedInst.Index,
......@@ -8109,7 +8092,7 @@ pub fn getStructType(
81098092 .cau = undefined, // set by `finish`
81108093 .zir_index = zir_index,
81118094 .fields_len = ini.fields_len,
8112 .namespace = .none,
8095 .namespace = undefined, // set by `finish`
81138096 .backing_int_ty = .none,
81148097 .names_map = names_map,
81158098 .flags = .{
......@@ -8142,10 +8125,7 @@ pub fn getStructType(
81428125 .index = gop.put(),
81438126 .type_name_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeStructPacked, "name").?,
81448127 .cau_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeStructPacked, "cau").?,
8145 .namespace_extra_index = if (ini.has_namespace)
8146 extra_index + std.meta.fieldIndex(Tag.TypeStructPacked, "namespace").?
8147 else
8148 null,
8128 .namespace_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeStructPacked, "namespace").?,
81498129 } };
81508130 },
81518131 };
......@@ -8164,11 +8144,12 @@ pub fn getStructType(
81648144 // zig fmt: on
81658145 (ini.fields_len * 5) + // types, names, inits, runtime order, offsets
81668146 align_elements_len + comptime_elements_len +
8167 2); // names_map + namespace
8147 1); // names_map
81688148 const extra_index = addExtraAssumeCapacity(extra, Tag.TypeStruct{
81698149 .name = undefined, // set by `finish`
81708150 .cau = undefined, // set by `finish`
81718151 .zir_index = zir_index,
8152 .namespace = undefined, // set by `finish`
81728153 .fields_len = ini.fields_len,
81738154 .size = std.math.maxInt(u32),
81748155 .flags = .{
......@@ -8179,7 +8160,6 @@ pub fn getStructType(
81798160 .is_tuple = ini.is_tuple,
81808161 .assumed_runtime_bits = false,
81818162 .assumed_pointer_aligned = false,
8182 .has_namespace = ini.has_namespace,
81838163 .any_comptime_fields = ini.any_comptime_fields,
81848164 .any_default_inits = ini.any_default_inits,
81858165 .any_aligned_fields = ini.any_aligned_fields,
......@@ -8215,10 +8195,6 @@ pub fn getStructType(
82158195 if (ini.any_default_inits) {
82168196 extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len);
82178197 }
8218 const namespace_extra_index: ?u32 = if (ini.has_namespace) i: {
8219 extra.appendAssumeCapacity(undefined); // set by `finish`
8220 break :i @intCast(extra.mutate.len - 1);
8221 } else null;
82228198 if (ini.any_aligned_fields) {
82238199 extra.appendNTimesAssumeCapacity(.{align_element}, align_elements_len);
82248200 }
......@@ -8234,7 +8210,7 @@ pub fn getStructType(
82348210 .index = gop.put(),
82358211 .type_name_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeStruct, "name").?,
82368212 .cau_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeStruct, "cau").?,
8237 .namespace_extra_index = namespace_extra_index,
8213 .namespace_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeStruct, "namespace").?,
82388214 } };
82398215}
82408216
......@@ -9002,7 +8978,6 @@ fn finishFuncInstance(
90028978}
90038979
90048980pub const EnumTypeInit = struct {
9005 has_namespace: bool,
90068981 has_values: bool,
90078982 tag_mode: LoadedEnumType.TagMode,
90088983 fields_len: u32,
......@@ -9024,7 +8999,7 @@ pub const WipEnumType = struct {
90248999 tag_ty_index: u32,
90259000 type_name_extra_index: u32,
90269001 cau_extra_index: u32,
9027 namespace_extra_index: ?u32,
9002 namespace_extra_index: u32,
90289003 names_map: MapIndex,
90299004 names_start: u32,
90309005 values_map: OptionalMapIndex,
......@@ -9044,18 +9019,13 @@ pub const WipEnumType = struct {
90449019 wip: WipEnumType,
90459020 ip: *InternPool,
90469021 analysis_owner: Cau.Index,
9047 namespace: OptionalNamespaceIndex,
9022 namespace: NamespaceIndex,
90489023 ) void {
90499024 const extra = ip.getLocalShared(wip.tid).extra.acquire();
90509025 const extra_items = extra.view().items(.@"0");
90519026
90529027 extra_items[wip.cau_extra_index] = @intFromEnum(analysis_owner);
9053
9054 if (wip.namespace_extra_index) |i| {
9055 extra_items[i] = @intFromEnum(namespace.unwrap().?);
9056 } else {
9057 assert(namespace == .none);
9058 }
9028 extra_items[wip.namespace_extra_index] = @intFromEnum(namespace);
90599029 }
90609030
90619031 pub fn setTagTy(wip: WipEnumType, ip: *InternPool, tag_ty: Index) void {
......@@ -9153,7 +9123,7 @@ pub fn getEnumType(
91539123 .declared => |d| @intCast(d.captures.len),
91549124 .reified => std.math.maxInt(u32),
91559125 },
9156 .namespace = .none,
9126 .namespace = undefined, // set by `prepare`
91579127 .int_tag_type = .none, // set by `prepare`
91589128 .fields_len = ini.fields_len,
91599129 .names_map = names_map,
......@@ -9179,7 +9149,7 @@ pub fn getEnumType(
91799149 .tag_ty_index = extra_index + std.meta.fieldIndex(EnumAuto, "int_tag_type").?,
91809150 .type_name_extra_index = extra_index + std.meta.fieldIndex(EnumAuto, "name").?,
91819151 .cau_extra_index = @intCast(cau_extra_index),
9182 .namespace_extra_index = if (ini.has_namespace) extra_index + std.meta.fieldIndex(EnumAuto, "namespace").? else null,
9152 .namespace_extra_index = extra_index + std.meta.fieldIndex(EnumAuto, "namespace").?,
91839153 .names_map = names_map,
91849154 .names_start = @intCast(names_start),
91859155 .values_map = .none,
......@@ -9213,7 +9183,7 @@ pub fn getEnumType(
92139183 .declared => |d| @intCast(d.captures.len),
92149184 .reified => std.math.maxInt(u32),
92159185 },
9216 .namespace = .none,
9186 .namespace = undefined, // set by `prepare`
92179187 .int_tag_type = .none, // set by `prepare`
92189188 .fields_len = ini.fields_len,
92199189 .names_map = names_map,
......@@ -9248,7 +9218,7 @@ pub fn getEnumType(
92489218 .tag_ty_index = extra_index + std.meta.fieldIndex(EnumExplicit, "int_tag_type").?,
92499219 .type_name_extra_index = extra_index + std.meta.fieldIndex(EnumExplicit, "name").?,
92509220 .cau_extra_index = @intCast(cau_extra_index),
9251 .namespace_extra_index = if (ini.has_namespace) extra_index + std.meta.fieldIndex(EnumExplicit, "namespace").? else null,
9221 .namespace_extra_index = extra_index + std.meta.fieldIndex(EnumExplicit, "namespace").?,
92529222 .names_map = names_map,
92539223 .names_start = @intCast(names_start),
92549224 .values_map = values_map,
......@@ -9265,6 +9235,7 @@ const GeneratedTagEnumTypeInit = struct {
92659235 names: []const NullTerminatedString,
92669236 values: []const Index,
92679237 tag_mode: LoadedEnumType.TagMode,
9238 parent_namespace: NamespaceIndex,
92689239};
92699240
92709241/// Creates an enum type which was automatically-generated as the tag type of a
......@@ -9291,6 +9262,18 @@ pub fn getGeneratedTagEnumType(
92919262
92929263 const fields_len: u32 = @intCast(ini.names.len);
92939264
9265 // Predict the index the enum will live at so we can construct the namespace before releasing the shard's mutex.
9266 const enum_index = Index.Unwrapped.wrap(.{
9267 .tid = tid,
9268 .index = items.mutate.len,
9269 }, ip);
9270 const namespace = try ip.createNamespace(gpa, tid, .{
9271 .parent = ini.parent_namespace.toOptional(),
9272 .owner_type = enum_index,
9273 .file_scope = ip.namespacePtr(ini.parent_namespace).file_scope,
9274 });
9275 errdefer ip.destroyNamespace(tid, namespace);
9276
92949277 const prev_extra_len = extra.mutate.len;
92959278 switch (ini.tag_mode) {
92969279 .auto => {
......@@ -9302,7 +9285,7 @@ pub fn getGeneratedTagEnumType(
93029285 .data = addExtraAssumeCapacity(extra, EnumAuto{
93039286 .name = ini.name,
93049287 .captures_len = 0,
9305 .namespace = .none,
9288 .namespace = namespace,
93069289 .int_tag_type = ini.tag_ty,
93079290 .fields_len = fields_len,
93089291 .names_map = names_map,
......@@ -9335,7 +9318,7 @@ pub fn getGeneratedTagEnumType(
93359318 .data = addExtraAssumeCapacity(extra, EnumExplicit{
93369319 .name = ini.name,
93379320 .captures_len = 0,
9338 .namespace = .none,
9321 .namespace = namespace,
93399322 .int_tag_type = ini.tag_ty,
93409323 .fields_len = fields_len,
93419324 .names_map = names_map,
......@@ -9360,11 +9343,11 @@ pub fn getGeneratedTagEnumType(
93609343 .generated_tag = .{ .union_type = ini.owner_union_ty },
93619344 } });
93629345 defer gop.deinit();
9363 return gop.put();
9346 assert(gop.put() == enum_index);
9347 return enum_index;
93649348}
93659349
93669350pub const OpaqueTypeInit = struct {
9367 has_namespace: bool,
93689351 key: union(enum) {
93699352 declared: struct {
93709353 zir_index: TrackedInst.Index,
......@@ -9407,7 +9390,7 @@ pub fn getOpaqueType(
94079390 });
94089391 const extra_index = addExtraAssumeCapacity(extra, Tag.TypeOpaque{
94099392 .name = undefined, // set by `finish`
9410 .namespace = .none,
9393 .namespace = undefined, // set by `finish`
94119394 .zir_index = switch (ini.key) {
94129395 inline else => |x| x.zir_index,
94139396 },
......@@ -9430,10 +9413,7 @@ pub fn getOpaqueType(
94309413 .index = gop.put(),
94319414 .type_name_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeOpaque, "name").?,
94329415 .cau_extra_index = null, // opaques do not undergo type resolution
9433 .namespace_extra_index = if (ini.has_namespace)
9434 extra_index + std.meta.fieldIndex(Tag.TypeOpaque, "namespace").?
9435 else
9436 null,
9416 .namespace_extra_index = extra_index + std.meta.fieldIndex(Tag.TypeOpaque, "namespace").?,
94379417 },
94389418 };
94399419}
......@@ -10332,7 +10312,6 @@ fn dumpStatsFallible(ip: *const InternPool, arena: Allocator) anyerror!void {
1033210312 }
1033310313 if (info.flags.any_default_inits)
1033410314 ints += info.fields_len; // inits
10335 ints += @intFromBool(info.flags.has_namespace); // namespace
1033610315 if (info.flags.any_aligned_fields)
1033710316 ints += (info.fields_len + 3) / 4; // aligns
1033810317 if (info.flags.any_comptime_fields)
src/Sema.zig+79-71
......@@ -2802,7 +2802,6 @@ fn zirStructDecl(
28022802 .any_default_inits = small.any_default_inits,
28032803 .inits_resolved = false,
28042804 .any_aligned_fields = small.any_aligned_fields,
2805 .has_namespace = true or decls_len > 0, // TODO: see below
28062805 .key = .{ .declared = .{
28072806 .zir_index = tracked_inst,
28082807 .captures = captures,
......@@ -2825,15 +2824,14 @@ fn zirStructDecl(
28252824 wip_ty.index,
28262825 ));
28272826
2828 // TODO: if AstGen tells us `@This` was not used in the fields, we can elide the namespace.
2829 const new_namespace_index: InternPool.OptionalNamespaceIndex = if (true or decls_len > 0) (try pt.createNamespace(.{
2827 const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
28302828 .parent = block.namespace.toOptional(),
28312829 .owner_type = wip_ty.index,
28322830 .file_scope = block.getFileScopeIndex(mod),
2833 })).toOptional() else .none;
2834 errdefer if (new_namespace_index.unwrap()) |ns| pt.destroyNamespace(ns);
2831 });
2832 errdefer pt.destroyNamespace(new_namespace_index);
28352833
2836 const new_cau_index = try ip.createTypeCau(gpa, pt.tid, tracked_inst, new_namespace_index.unwrap() orelse block.namespace, wip_ty.index);
2834 const new_cau_index = try ip.createTypeCau(gpa, pt.tid, tracked_inst, new_namespace_index, wip_ty.index);
28372835
28382836 if (pt.zcu.comp.incremental) {
28392837 try ip.addDependency(
......@@ -2843,10 +2841,8 @@ fn zirStructDecl(
28432841 );
28442842 }
28452843
2846 if (new_namespace_index.unwrap()) |ns| {
2847 const decls = sema.code.bodySlice(extra_index, decls_len);
2848 try pt.scanNamespace(ns, decls);
2849 }
2844 const decls = sema.code.bodySlice(extra_index, decls_len);
2845 try pt.scanNamespace(new_namespace_index, decls);
28502846
28512847 try mod.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
28522848 try sema.addReferenceEntry(src, AnalUnit.wrap(.{ .cau = new_cau_index }));
......@@ -3015,7 +3011,6 @@ fn zirEnumDecl(
30153011 } else false;
30163012
30173013 const enum_init: InternPool.EnumTypeInit = .{
3018 .has_namespace = true or decls_len > 0, // TODO: see below
30193014 .has_values = any_values,
30203015 .tag_mode = if (small.nonexhaustive)
30213016 .nonexhaustive
......@@ -3052,15 +3047,14 @@ fn zirEnumDecl(
30523047 );
30533048 wip_ty.setName(ip, type_name);
30543049
3055 // TODO: if AstGen tells us `@This` was not used in the fields, we can elide the namespace.
3056 const new_namespace_index: InternPool.OptionalNamespaceIndex = if (true or decls_len > 0) (try pt.createNamespace(.{
3050 const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
30573051 .parent = block.namespace.toOptional(),
30583052 .owner_type = wip_ty.index,
30593053 .file_scope = block.getFileScopeIndex(mod),
3060 })).toOptional() else .none;
3061 errdefer if (!done) if (new_namespace_index.unwrap()) |ns| pt.destroyNamespace(ns);
3054 });
3055 errdefer if (!done) pt.destroyNamespace(new_namespace_index);
30623056
3063 const new_cau_index = try ip.createTypeCau(gpa, pt.tid, tracked_inst, new_namespace_index.unwrap() orelse block.namespace, wip_ty.index);
3057 const new_cau_index = try ip.createTypeCau(gpa, pt.tid, tracked_inst, new_namespace_index, wip_ty.index);
30643058
30653059 if (pt.zcu.comp.incremental) {
30663060 try mod.intern_pool.addDependency(
......@@ -3070,9 +3064,7 @@ fn zirEnumDecl(
30703064 );
30713065 }
30723066
3073 if (new_namespace_index.unwrap()) |ns| {
3074 try pt.scanNamespace(ns, decls);
3075 }
3067 try pt.scanNamespace(new_namespace_index, decls);
30763068
30773069 try sema.addReferenceEntry(src, AnalUnit.wrap(.{ .cau = new_cau_index }));
30783070 try sema.declareDependency(.{ .interned = wip_ty.index });
......@@ -3098,7 +3090,7 @@ fn zirEnumDecl(
30983090 var enum_block: Block = .{
30993091 .parent = null,
31003092 .sema = sema,
3101 .namespace = new_namespace_index.unwrap() orelse block.namespace,
3093 .namespace = new_namespace_index,
31023094 .instructions = .{},
31033095 .inlining = null,
31043096 .is_comptime = true,
......@@ -3284,7 +3276,6 @@ fn zirUnionDecl(
32843276 .assumed_pointer_aligned = false,
32853277 .alignment = .none,
32863278 },
3287 .has_namespace = true or decls_len != 0, // TODO: see below
32883279 .fields_len = fields_len,
32893280 .enum_tag_ty = .none, // set later
32903281 .field_types = &.{}, // set later
......@@ -3311,15 +3302,14 @@ fn zirUnionDecl(
33113302 wip_ty.index,
33123303 ));
33133304
3314 // TODO: if AstGen tells us `@This` was not used in the fields, we can elide the namespace.
3315 const new_namespace_index: InternPool.OptionalNamespaceIndex = if (true or decls_len > 0) (try pt.createNamespace(.{
3305 const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
33163306 .parent = block.namespace.toOptional(),
33173307 .owner_type = wip_ty.index,
33183308 .file_scope = block.getFileScopeIndex(mod),
3319 })).toOptional() else .none;
3320 errdefer if (new_namespace_index.unwrap()) |ns| pt.destroyNamespace(ns);
3309 });
3310 errdefer pt.destroyNamespace(new_namespace_index);
33213311
3322 const new_cau_index = try ip.createTypeCau(gpa, pt.tid, tracked_inst, new_namespace_index.unwrap() orelse block.namespace, wip_ty.index);
3312 const new_cau_index = try ip.createTypeCau(gpa, pt.tid, tracked_inst, new_namespace_index, wip_ty.index);
33233313
33243314 if (pt.zcu.comp.incremental) {
33253315 try mod.intern_pool.addDependency(
......@@ -3329,10 +3319,8 @@ fn zirUnionDecl(
33293319 );
33303320 }
33313321
3332 if (new_namespace_index.unwrap()) |ns| {
3333 const decls = sema.code.bodySlice(extra_index, decls_len);
3334 try pt.scanNamespace(ns, decls);
3335 }
3322 const decls = sema.code.bodySlice(extra_index, decls_len);
3323 try pt.scanNamespace(new_namespace_index, decls);
33363324
33373325 try mod.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
33383326 try sema.addReferenceEntry(src, AnalUnit.wrap(.{ .cau = new_cau_index }));
......@@ -3377,7 +3365,6 @@ fn zirOpaqueDecl(
33773365 extra_index += captures_len;
33783366
33793367 const opaque_init: InternPool.OpaqueTypeInit = .{
3380 .has_namespace = decls_len != 0,
33813368 .key = .{ .declared = .{
33823369 .zir_index = tracked_inst,
33833370 .captures = captures,
......@@ -3399,17 +3386,15 @@ fn zirOpaqueDecl(
33993386 wip_ty.index,
34003387 ));
34013388
3402 const new_namespace_index: InternPool.OptionalNamespaceIndex = if (decls_len > 0) (try pt.createNamespace(.{
3389 const new_namespace_index: InternPool.NamespaceIndex = try pt.createNamespace(.{
34033390 .parent = block.namespace.toOptional(),
34043391 .owner_type = wip_ty.index,
34053392 .file_scope = block.getFileScopeIndex(mod),
3406 })).toOptional() else .none;
3407 errdefer if (new_namespace_index.unwrap()) |ns| pt.destroyNamespace(ns);
3393 });
3394 errdefer pt.destroyNamespace(new_namespace_index);
34083395
3409 if (new_namespace_index.unwrap()) |ns| {
3410 const decls = sema.code.bodySlice(extra_index, decls_len);
3411 try pt.scanNamespace(ns, decls);
3412 }
3396 const decls = sema.code.bodySlice(extra_index, decls_len);
3397 try pt.scanNamespace(new_namespace_index, decls);
34133398
34143399 return Air.internedToRef(wip_ty.finish(ip, .none, new_namespace_index));
34153400}
......@@ -6749,7 +6734,7 @@ fn lookupIdentifier(sema: *Sema, block: *Block, src: LazySrcLoc, name: InternPoo
67496734 const mod = pt.zcu;
67506735 var namespace = block.namespace;
67516736 while (true) {
6752 if (try sema.lookupInNamespace(block, src, namespace.toOptional(), name, false)) |lookup| {
6737 if (try sema.lookupInNamespace(block, src, namespace, name, false)) |lookup| {
67536738 assert(lookup.accessible);
67546739 return lookup.nav;
67556740 }
......@@ -6764,7 +6749,7 @@ fn lookupInNamespace(
67646749 sema: *Sema,
67656750 block: *Block,
67666751 src: LazySrcLoc,
6767 opt_namespace_index: InternPool.OptionalNamespaceIndex,
6752 namespace_index: InternPool.NamespaceIndex,
67686753 ident_name: InternPool.NullTerminatedString,
67696754 observe_usingnamespace: bool,
67706755) CompileError!?struct {
......@@ -6777,7 +6762,6 @@ fn lookupInNamespace(
67776762 const zcu = pt.zcu;
67786763 const ip = &zcu.intern_pool;
67796764
6780 const namespace_index = opt_namespace_index.unwrap() orelse return null;
67816765 const namespace = zcu.namespacePtr(namespace_index);
67826766
67836767 const adapter: Zcu.Namespace.NameAdapter = .{ .zcu = zcu };
......@@ -6816,7 +6800,7 @@ fn lookupInNamespace(
68166800 for (usingnamespaces.items) |sub_ns_nav| {
68176801 try sema.ensureNavResolved(src, sub_ns_nav);
68186802 const sub_ns_ty = Type.fromInterned(ip.getNav(sub_ns_nav).status.resolved.val);
6819 const sub_ns = zcu.namespacePtrUnwrap(sub_ns_ty.getNamespaceIndex(zcu)) orelse continue;
6803 const sub_ns = zcu.namespacePtr(sub_ns_ty.getNamespaceIndex(zcu));
68206804 try checked_namespaces.put(gpa, sub_ns, {});
68216805 }
68226806 }
......@@ -13952,7 +13936,7 @@ fn zirHasDecl(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
1395213936 } });
1395313937 }
1395413938
13955 const namespace = container_type.getNamespaceIndex(mod);
13939 const namespace = container_type.getNamespace(mod).unwrap() orelse return .bool_false;
1395613940 if (try sema.lookupInNamespace(block, src, namespace, decl_name, true)) |lookup| {
1395713941 if (lookup.accessible) {
1395813942 return .bool_true;
......@@ -18436,7 +18420,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1843618420 } });
1843718421 };
1843818422
18439 const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ip.loadEnumType(ty.toIntern()).namespace);
18423 const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ip.loadEnumType(ty.toIntern()).namespace.toOptional());
1844018424
1844118425 const type_enum_ty = t: {
1844218426 const nav = try sema.namespaceLookup(
......@@ -18577,7 +18561,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1857718561 } });
1857818562 };
1857918563
18580 const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ty.getNamespaceIndex(mod));
18564 const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ty.getNamespaceIndex(mod).toOptional());
1858118565
1858218566 const enum_tag_ty_val = try pt.intern(.{ .opt = .{
1858318567 .ty = (try pt.optionalType(.type_type)).toIntern(),
......@@ -18804,7 +18788,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1880418788 } });
1880518789 };
1880618790
18807 const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ty.getNamespaceIndex(mod));
18791 const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ty.getNamespace(mod));
1880818792
1880918793 const backing_integer_val = try pt.intern(.{ .opt = .{
1881018794 .ty = (try pt.optionalType(.type_type)).toIntern(),
......@@ -18861,7 +18845,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1886118845 };
1886218846
1886318847 try ty.resolveFields(pt);
18864 const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ty.getNamespaceIndex(mod));
18848 const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ty.getNamespace(mod));
1886518849
1886618850 const field_values = .{
1886718851 // decls: []const Declaration,
......@@ -19009,7 +18993,7 @@ fn typeInfoNamespaceDecls(
1900918993 }
1901018994 try sema.ensureNavResolved(src, nav);
1901118995 const namespace_ty = Type.fromInterned(ip.getNav(nav).status.resolved.val);
19012 try sema.typeInfoNamespaceDecls(block, src, namespace_ty.getNamespaceIndex(zcu), declaration_ty, decl_vals, seen_namespaces);
18996 try sema.typeInfoNamespaceDecls(block, src, namespace_ty.getNamespaceIndex(zcu).toOptional(), declaration_ty, decl_vals, seen_namespaces);
1901318997 }
1901418998}
1901518999
......@@ -21798,7 +21782,6 @@ fn zirReify(
2179821782 }
2179921783
2180021784 const wip_ty = switch (try ip.getOpaqueType(gpa, pt.tid, .{
21801 .has_namespace = false,
2180221785 .key = .{ .reified = .{
2180321786 .zir_index = try block.trackZir(inst),
2180421787 } },
......@@ -21816,7 +21799,13 @@ fn zirReify(
2181621799 wip_ty.index,
2181721800 ));
2181821801
21819 return Air.internedToRef(wip_ty.finish(ip, .none, .none));
21802 const new_namespace_index = try pt.createNamespace(.{
21803 .parent = block.namespace.toOptional(),
21804 .owner_type = wip_ty.index,
21805 .file_scope = block.getFileScopeIndex(mod),
21806 });
21807
21808 return Air.internedToRef(wip_ty.finish(ip, .none, new_namespace_index));
2182021809 },
2182121810 .Union => {
2182221811 const struct_type = ip.loadStructType(ip.typeOf(union_val.val));
......@@ -21988,7 +21977,6 @@ fn reifyEnum(
2198821977 const tracked_inst = try block.trackZir(inst);
2198921978
2199021979 const wip_ty = switch (try ip.getEnumType(gpa, pt.tid, .{
21991 .has_namespace = false,
2199221980 .has_values = true,
2199321981 .tag_mode = if (is_exhaustive) .explicit else .nonexhaustive,
2199421982 .fields_len = fields_len,
......@@ -22014,9 +22002,15 @@ fn reifyEnum(
2201422002 wip_ty.index,
2201522003 ));
2201622004
22017 const new_cau_index = try ip.createTypeCau(gpa, pt.tid, tracked_inst, block.namespace, wip_ty.index);
22005 const new_namespace_index = try pt.createNamespace(.{
22006 .parent = block.namespace.toOptional(),
22007 .owner_type = wip_ty.index,
22008 .file_scope = block.getFileScopeIndex(mod),
22009 });
22010
22011 const new_cau_index = try ip.createTypeCau(gpa, pt.tid, tracked_inst, new_namespace_index, wip_ty.index);
2201822012
22019 wip_ty.prepare(ip, new_cau_index, .none);
22013 wip_ty.prepare(ip, new_cau_index, new_namespace_index);
2202022014 wip_ty.setTagTy(ip, tag_ty.toIntern());
2202122015
2202222016 for (0..fields_len) |field_idx| {
......@@ -22139,7 +22133,6 @@ fn reifyUnion(
2213922133 .assumed_pointer_aligned = false,
2214022134 .alignment = .none,
2214122135 },
22142 .has_namespace = false,
2214322136 .fields_len = fields_len,
2214422137 .enum_tag_ty = .none, // set later because not yet validated
2214522138 .field_types = &.{}, // set later
......@@ -22254,7 +22247,7 @@ fn reifyUnion(
2225422247 }
2225522248 }
2225622249
22257 const enum_tag_ty = try sema.generateUnionTagTypeSimple(field_names.keys(), wip_ty.index, type_name);
22250 const enum_tag_ty = try sema.generateUnionTagTypeSimple(block, field_names.keys(), wip_ty.index, type_name);
2225822251 break :tag_ty .{ enum_tag_ty, false };
2225922252 };
2226022253 errdefer if (!has_explicit_tag) ip.remove(pt.tid, enum_tag_ty); // remove generated tag type on error
......@@ -22301,11 +22294,17 @@ fn reifyUnion(
2230122294 loaded_union.setTagType(ip, enum_tag_ty);
2230222295 loaded_union.setStatus(ip, .have_field_types);
2230322296
22304 const new_cau_index = try ip.createTypeCau(gpa, pt.tid, tracked_inst, block.namespace, wip_ty.index);
22297 const new_namespace_index = try pt.createNamespace(.{
22298 .parent = block.namespace.toOptional(),
22299 .owner_type = wip_ty.index,
22300 .file_scope = block.getFileScopeIndex(mod),
22301 });
22302
22303 const new_cau_index = try ip.createTypeCau(gpa, pt.tid, tracked_inst, new_namespace_index, wip_ty.index);
2230522304
2230622305 try mod.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
2230722306 try sema.addReferenceEntry(src, AnalUnit.wrap(.{ .cau = new_cau_index }));
22308 return Air.internedToRef(wip_ty.finish(ip, new_cau_index.toOptional(), .none));
22307 return Air.internedToRef(wip_ty.finish(ip, new_cau_index.toOptional(), new_namespace_index));
2230922308}
2231022309
2231122310fn reifyStruct(
......@@ -22398,7 +22397,6 @@ fn reifyStruct(
2239822397 .any_default_inits = any_default_inits,
2239922398 .any_aligned_fields = any_aligned_fields,
2240022399 .inits_resolved = true,
22401 .has_namespace = false,
2240222400 .key = .{ .reified = .{
2240322401 .zir_index = tracked_inst,
2240422402 .type_hash = hasher.final(),
......@@ -22569,11 +22567,17 @@ fn reifyStruct(
2256922567 }
2257022568 }
2257122569
22572 const new_cau_index = try ip.createTypeCau(gpa, pt.tid, tracked_inst, block.namespace, wip_ty.index);
22570 const new_namespace_index = try pt.createNamespace(.{
22571 .parent = block.namespace.toOptional(),
22572 .owner_type = wip_ty.index,
22573 .file_scope = block.getFileScopeIndex(mod),
22574 });
22575
22576 const new_cau_index = try ip.createTypeCau(gpa, pt.tid, tracked_inst, new_namespace_index, wip_ty.index);
2257322577
2257422578 try mod.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
2257522579 try sema.addReferenceEntry(src, AnalUnit.wrap(.{ .cau = new_cau_index }));
22576 return Air.internedToRef(wip_ty.finish(ip, new_cau_index.toOptional(), .none));
22580 return Air.internedToRef(wip_ty.finish(ip, new_cau_index.toOptional(), new_namespace_index));
2257722581}
2257822582
2257922583fn resolveVaListRef(sema: *Sema, block: *Block, src: LazySrcLoc, zir_ref: Zir.Inst.Ref) CompileError!Air.Inst.Ref {
......@@ -28022,7 +28026,7 @@ fn fieldCallBind(
2802228026
2802328027 // If we get here, we need to look for a decl in the struct type instead.
2802428028 const found_nav = found_nav: {
28025 const namespace = concrete_ty.getNamespace(zcu) orelse
28029 const namespace = concrete_ty.getNamespace(zcu).unwrap() orelse
2802628030 break :found_nav null;
2802728031 const nav_index = try sema.namespaceLookup(block, src, namespace, field_name) orelse
2802828032 break :found_nav null;
......@@ -28154,13 +28158,13 @@ fn namespaceLookup(
2815428158 sema: *Sema,
2815528159 block: *Block,
2815628160 src: LazySrcLoc,
28157 opt_namespace: InternPool.OptionalNamespaceIndex,
28161 namespace: InternPool.NamespaceIndex,
2815828162 decl_name: InternPool.NullTerminatedString,
2815928163) CompileError!?InternPool.Nav.Index {
2816028164 const pt = sema.pt;
2816128165 const zcu = pt.zcu;
2816228166 const gpa = sema.gpa;
28163 if (try sema.lookupInNamespace(block, src, opt_namespace, decl_name, true)) |lookup| {
28167 if (try sema.lookupInNamespace(block, src, namespace, decl_name, true)) |lookup| {
2816428168 if (!lookup.accessible) {
2816528169 return sema.failWithOwnedErrorMsg(block, msg: {
2816628170 const msg = try sema.errMsg(src, "'{}' is not marked 'pub'", .{
......@@ -28180,10 +28184,10 @@ fn namespaceLookupRef(
2818028184 sema: *Sema,
2818128185 block: *Block,
2818228186 src: LazySrcLoc,
28183 opt_namespace: InternPool.OptionalNamespaceIndex,
28187 namespace: InternPool.NamespaceIndex,
2818428188 decl_name: InternPool.NullTerminatedString,
2818528189) CompileError!?Air.Inst.Ref {
28186 const nav = try sema.namespaceLookup(block, src, opt_namespace, decl_name) orelse return null;
28190 const nav = try sema.namespaceLookup(block, src, namespace, decl_name) orelse return null;
2818728191 return try sema.analyzeNavRef(src, nav);
2818828192}
2818928193
......@@ -28191,10 +28195,10 @@ fn namespaceLookupVal(
2819128195 sema: *Sema,
2819228196 block: *Block,
2819328197 src: LazySrcLoc,
28194 opt_namespace: InternPool.OptionalNamespaceIndex,
28198 namespace: InternPool.NamespaceIndex,
2819528199 decl_name: InternPool.NullTerminatedString,
2819628200) CompileError!?Air.Inst.Ref {
28197 const nav = try sema.namespaceLookup(block, src, opt_namespace, decl_name) orelse return null;
28201 const nav = try sema.namespaceLookup(block, src, namespace, decl_name) orelse return null;
2819828202 return try sema.analyzeNavVal(block, src, nav);
2819928203}
2820028204
......@@ -36422,7 +36426,7 @@ fn semaUnionFields(pt: Zcu.PerThread, arena: Allocator, union_ty: InternPool.Ind
3642236426 const gpa = zcu.gpa;
3642336427 const ip = &zcu.intern_pool;
3642436428 const cau_index = union_type.cau;
36425 const zir = zcu.namespacePtr(union_type.namespace.unwrap().?).fileScope(zcu).zir;
36429 const zir = zcu.namespacePtr(union_type.namespace).fileScope(zcu).zir;
3642636430 const zir_index = union_type.zir_index.resolve(ip);
3642736431 const extended = zir.instructions.items(.data)[@intFromEnum(zir_index)].extended;
3642836432 assert(extended.opcode == .union_decl);
......@@ -36486,7 +36490,7 @@ fn semaUnionFields(pt: Zcu.PerThread, arena: Allocator, union_ty: InternPool.Ind
3648636490 var block_scope: Block = .{
3648736491 .parent = null,
3648836492 .sema = &sema,
36489 .namespace = union_type.namespace.unwrap().?,
36493 .namespace = union_type.namespace,
3649036494 .instructions = .{},
3649136495 .inlining = null,
3649236496 .is_comptime = true,
......@@ -36778,10 +36782,10 @@ fn semaUnionFields(pt: Zcu.PerThread, arena: Allocator, union_ty: InternPool.Ind
3677836782 return sema.failWithOwnedErrorMsg(&block_scope, msg);
3677936783 }
3678036784 } else if (enum_field_vals.count() > 0) {
36781 const enum_ty = try sema.generateUnionTagTypeNumbered(enum_field_names, enum_field_vals.keys(), union_ty, union_type.name);
36785 const enum_ty = try sema.generateUnionTagTypeNumbered(&block_scope, enum_field_names, enum_field_vals.keys(), union_ty, union_type.name);
3678236786 union_type.setTagType(ip, enum_ty);
3678336787 } else {
36784 const enum_ty = try sema.generateUnionTagTypeSimple(enum_field_names, union_ty, union_type.name);
36788 const enum_ty = try sema.generateUnionTagTypeSimple(&block_scope, enum_field_names, union_ty, union_type.name);
3678536789 union_type.setTagType(ip, enum_ty);
3678636790 }
3678736791
......@@ -36797,6 +36801,7 @@ fn semaUnionFieldVal(sema: *Sema, block: *Block, src: LazySrcLoc, int_tag_ty: Ty
3679736801
3679836802fn generateUnionTagTypeNumbered(
3679936803 sema: *Sema,
36804 block: *Block,
3680036805 enum_field_names: []const InternPool.NullTerminatedString,
3680136806 enum_field_vals: []const InternPool.Index,
3680236807 union_type: InternPool.Index,
......@@ -36825,6 +36830,7 @@ fn generateUnionTagTypeNumbered(
3682536830 .names = enum_field_names,
3682636831 .values = enum_field_vals,
3682736832 .tag_mode = .explicit,
36833 .parent_namespace = block.namespace,
3682836834 });
3682936835
3683036836 return enum_ty;
......@@ -36832,6 +36838,7 @@ fn generateUnionTagTypeNumbered(
3683236838
3683336839fn generateUnionTagTypeSimple(
3683436840 sema: *Sema,
36841 block: *Block,
3683536842 enum_field_names: []const InternPool.NullTerminatedString,
3683636843 union_type: InternPool.Index,
3683736844 union_name: InternPool.NullTerminatedString,
......@@ -36859,6 +36866,7 @@ fn generateUnionTagTypeSimple(
3685936866 .names = enum_field_names,
3686036867 .values = &.{},
3686136868 .tag_mode = .auto,
36869 .parent_namespace = block.namespace,
3686236870 });
3686336871
3686436872 return enum_ty;
src/Type.zig+9-43
......@@ -2968,59 +2968,25 @@ pub fn indexableHasLen(ty: Type, mod: *Module) bool {
29682968}
29692969
29702970/// Asserts that the type can have a namespace.
2971pub fn getNamespaceIndex(ty: Type, zcu: *Zcu) InternPool.OptionalNamespaceIndex {
2972 return ty.getNamespace(zcu).?;
2971pub fn getNamespaceIndex(ty: Type, zcu: *Zcu) InternPool.NamespaceIndex {
2972 return ty.getNamespace(zcu).unwrap().?;
29732973}
29742974
29752975/// Returns null if the type has no namespace.
2976pub fn getNamespace(ty: Type, zcu: *Zcu) ?InternPool.OptionalNamespaceIndex {
2976pub fn getNamespace(ty: Type, zcu: *Zcu) InternPool.OptionalNamespaceIndex {
29772977 const ip = &zcu.intern_pool;
29782978 return switch (ip.indexToKey(ty.toIntern())) {
2979 .opaque_type => ip.loadOpaqueType(ty.toIntern()).namespace,
2979 .opaque_type => ip.loadOpaqueType(ty.toIntern()).namespace.toOptional(),
29802980 .struct_type => ip.loadStructType(ty.toIntern()).namespace,
2981 .union_type => ip.loadUnionType(ty.toIntern()).namespace,
2982 .enum_type => ip.loadEnumType(ty.toIntern()).namespace,
2983
2984 .anon_struct_type => .none,
2985 .simple_type => |s| switch (s) {
2986 .anyopaque,
2987 .atomic_order,
2988 .atomic_rmw_op,
2989 .calling_convention,
2990 .address_space,
2991 .float_mode,
2992 .reduce_op,
2993 .call_modifier,
2994 .prefetch_options,
2995 .export_options,
2996 .extern_options,
2997 .type_info,
2998 => .none,
2999 else => null,
3000 },
3001
3002 else => null,
2981 .union_type => ip.loadUnionType(ty.toIntern()).namespace.toOptional(),
2982 .enum_type => ip.loadEnumType(ty.toIntern()).namespace.toOptional(),
2983 else => .none,
30032984 };
30042985}
30052986
30062987// TODO: new dwarf structure will also need the enclosing code block for types created in imperative scopes
3007pub fn getParentNamespace(ty: Type, zcu: *Zcu) ?InternPool.OptionalNamespaceIndex {
3008 const ip = &zcu.intern_pool;
3009 const cau = switch (ip.indexToKey(ty.toIntern())) {
3010 .struct_type => ip.loadStructType(ty.toIntern()).cau,
3011 .union_type => ip.loadUnionType(ty.toIntern()).cau.toOptional(),
3012 .enum_type => |e| switch (e) {
3013 .declared, .reified => ip.loadEnumType(ty.toIntern()).cau,
3014 .generated_tag => |gt| ip.loadUnionType(gt.union_type).cau.toOptional(),
3015 .empty_struct => unreachable,
3016 },
3017 // TODO: this doesn't handle opaque types with empty namespaces
3018 .opaque_type => return ip.namespacePtr(ip.loadOpaqueType(ty.toIntern()).namespace.unwrap().?).parent,
3019 else => return null,
3020 };
3021 return ip.namespacePtr(ip.getCau(cau.unwrap() orelse return .none).namespace)
3022 // TODO: I thought the cau contained the parent namespace based on "analyzed within" but alas
3023 .parent;
2988pub fn getParentNamespace(ty: Type, zcu: *Zcu) InternPool.OptionalNamespaceIndex {
2989 return zcu.namespacePtr(ty.getNamespace(zcu).unwrap() orelse return .none).parent;
30242990}
30252991
30262992// Works for vectors and vectors of integers.
src/Zcu/PerThread.zig+8-10
......@@ -887,7 +887,6 @@ fn createFileRootStruct(
887887 .any_default_inits = small.any_default_inits,
888888 .inits_resolved = false,
889889 .any_aligned_fields = small.any_aligned_fields,
890 .has_namespace = true,
891890 .key = .{ .declared = .{
892891 .zir_index = tracked_inst,
893892 .captures = &.{},
......@@ -913,7 +912,7 @@ fn createFileRootStruct(
913912 try pt.scanNamespace(namespace_index, decls);
914913 try zcu.comp.queueJob(.{ .resolve_type_fully = wip_ty.index });
915914 zcu.setFileRootType(file_index, wip_ty.index);
916 return wip_ty.finish(ip, new_cau_index.toOptional(), namespace_index.toOptional());
915 return wip_ty.finish(ip, new_cau_index.toOptional(), namespace_index);
917916}
918917
919918/// Re-analyze the root type of a file on an incremental update.
......@@ -926,7 +925,7 @@ fn semaFileUpdate(pt: Zcu.PerThread, file_index: Zcu.File.Index, type_outdated:
926925 const ip = &zcu.intern_pool;
927926 const file = zcu.fileByIndex(file_index);
928927 const file_root_type = zcu.fileRootType(file_index);
929 const namespace_index = Type.fromInterned(file_root_type).getNamespaceIndex(zcu).unwrap().?;
928 const namespace_index = Type.fromInterned(file_root_type).getNamespaceIndex(zcu);
930929
931930 assert(file_root_type != .none);
932931
......@@ -1083,12 +1082,12 @@ fn semaCau(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) !SemaCauResult {
10831082 const nav_name = ip.getNav(nav).name;
10841083 const std_file_imported = try pt.importPkg(zcu.std_mod);
10851084 const std_type = Type.fromInterned(zcu.fileRootType(std_file_imported.file_index));
1086 const std_namespace = zcu.namespacePtr(std_type.getNamespace(zcu).?.unwrap().?);
1085 const std_namespace = zcu.namespacePtr(std_type.getNamespace(zcu).unwrap().?);
10871086 const builtin_str = try ip.getOrPutString(gpa, pt.tid, "builtin", .no_embedded_nulls);
10881087 const builtin_nav = ip.getNav(std_namespace.pub_decls.getKeyAdapted(builtin_str, Zcu.Namespace.NameAdapter{ .zcu = zcu }) orelse break :ip_index .none);
10891088 const builtin_namespace = switch (builtin_nav.status) {
10901089 .unresolved => break :ip_index .none,
1091 .resolved => |r| Type.fromInterned(r.val).getNamespace(zcu).?.unwrap().?,
1090 .resolved => |r| Type.fromInterned(r.val).getNamespace(zcu).unwrap().?,
10921091 };
10931092 if (cau.namespace != builtin_namespace) break :ip_index .none;
10941093 // We're in builtin.zig. This could be a builtin we need to add to a specific InternPool index.
......@@ -1232,7 +1231,7 @@ fn semaCau(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) !SemaCauResult {
12321231 if (decl_ty.toIntern() != .type_type) {
12331232 return sema.fail(&block, ty_src, "expected type, found {}", .{decl_ty.fmt(pt)});
12341233 }
1235 if (decl_val.toType().getNamespace(zcu) == null) {
1234 if (decl_val.toType().getNamespace(zcu) == .none) {
12361235 return sema.fail(&block, ty_src, "type {} has no namespace", .{decl_val.toType().fmt(pt)});
12371236 }
12381237 ip.resolveNavValue(nav_index, .{
......@@ -2432,7 +2431,7 @@ pub fn populateTestFunctions(
24322431 error.OutOfMemory => |e| return e,
24332432 };
24342433 const builtin_root_type = Type.fromInterned(zcu.fileRootType(builtin_file_index));
2435 const builtin_namespace = builtin_root_type.getNamespace(zcu).?.unwrap().?;
2434 const builtin_namespace = builtin_root_type.getNamespace(zcu).unwrap().?;
24362435 const nav_index = zcu.namespacePtr(builtin_namespace).pub_decls.getKeyAdapted(
24372436 try ip.getOrPutString(gpa, pt.tid, "test_functions", .no_embedded_nulls),
24382437 Zcu.Namespace.NameAdapter{ .zcu = zcu },
......@@ -3196,14 +3195,13 @@ pub fn getBuiltinNav(pt: Zcu.PerThread, name: []const u8) Allocator.Error!Intern
31963195 const ip = &zcu.intern_pool;
31973196 const std_file_imported = pt.importPkg(zcu.std_mod) catch @panic("failed to import lib/std.zig");
31983197 const std_type = Type.fromInterned(zcu.fileRootType(std_file_imported.file_index));
3199 const std_namespace = zcu.namespacePtr(std_type.getNamespace(zcu).?.unwrap().?);
3198 const std_namespace = zcu.namespacePtr(std_type.getNamespace(zcu).unwrap().?);
32003199 const builtin_str = try ip.getOrPutString(gpa, pt.tid, "builtin", .no_embedded_nulls);
32013200 const builtin_nav = std_namespace.pub_decls.getKeyAdapted(builtin_str, Zcu.Namespace.NameAdapter{ .zcu = zcu }) orelse
32023201 @panic("lib/std.zig is corrupt and missing 'builtin'");
32033202 pt.ensureCauAnalyzed(ip.getNav(builtin_nav).analysis_owner.unwrap().?) catch @panic("std.builtin is corrupt");
32043203 const builtin_type = Type.fromInterned(ip.getNav(builtin_nav).status.resolved.val);
3205 const builtin_namespace_index = (if (builtin_type.getNamespace(zcu)) |n| n.unwrap() else null) orelse @panic("std.builtin is corrupt");
3206 const builtin_namespace = zcu.namespacePtr(builtin_namespace_index);
3204 const builtin_namespace = zcu.namespacePtr(builtin_type.getNamespace(zcu).unwrap() orelse @panic("std.builtin is corrupt"));
32073205 const name_str = try ip.getOrPutString(gpa, pt.tid, name, .no_embedded_nulls);
32083206 return builtin_namespace.pub_decls.getKeyAdapted(name_str, Zcu.Namespace.NameAdapter{ .zcu = zcu }) orelse @panic("lib/std/builtin.zig is corrupt");
32093207}
src/codegen/llvm.zig+5-5
......@@ -1958,7 +1958,7 @@ pub const Object = struct {
19581958 }
19591959
19601960 const file = try o.getDebugFile(ty.typeDeclInstAllowGeneratedTag(zcu).?.resolveFull(ip).file);
1961 const scope = if (ty.getParentNamespace(zcu).?.unwrap()) |parent_namespace|
1961 const scope = if (ty.getParentNamespace(zcu).unwrap()) |parent_namespace|
19621962 try o.namespaceToDebugScope(parent_namespace)
19631963 else
19641964 file;
......@@ -2136,7 +2136,7 @@ pub const Object = struct {
21362136 defer gpa.free(name);
21372137
21382138 const file = try o.getDebugFile(ty.typeDeclInstAllowGeneratedTag(zcu).?.resolveFull(ip).file);
2139 const scope = if (ty.getParentNamespace(zcu).?.unwrap()) |parent_namespace|
2139 const scope = if (ty.getParentNamespace(zcu).unwrap()) |parent_namespace|
21402140 try o.namespaceToDebugScope(parent_namespace)
21412141 else
21422142 file;
......@@ -2771,7 +2771,7 @@ pub const Object = struct {
27712771 const zcu = o.pt.zcu;
27722772 const ip = &zcu.intern_pool;
27732773 const file = try o.getDebugFile(ty.typeDeclInstAllowGeneratedTag(zcu).?.resolveFull(ip).file);
2774 const scope = if (ty.getParentNamespace(zcu).?.unwrap()) |parent_namespace|
2774 const scope = if (ty.getParentNamespace(zcu).unwrap()) |parent_namespace|
27752775 try o.namespaceToDebugScope(parent_namespace)
27762776 else
27772777 file;
......@@ -2797,13 +2797,13 @@ pub const Object = struct {
27972797
27982798 const builtin_str = try ip.getOrPutString(zcu.gpa, pt.tid, "builtin", .no_embedded_nulls);
27992799 const std_file_root_type = Type.fromInterned(zcu.fileRootType(std_file_imported.file_index));
2800 const std_namespace = ip.namespacePtr(std_file_root_type.getNamespaceIndex(zcu).unwrap().?);
2800 const std_namespace = ip.namespacePtr(std_file_root_type.getNamespaceIndex(zcu));
28012801 const builtin_nav = std_namespace.pub_decls.getKeyAdapted(builtin_str, Zcu.Namespace.NameAdapter{ .zcu = zcu }).?;
28022802
28032803 const stack_trace_str = try ip.getOrPutString(zcu.gpa, pt.tid, "StackTrace", .no_embedded_nulls);
28042804 // buffer is only used for int_type, `builtin` is a struct.
28052805 const builtin_ty = zcu.navValue(builtin_nav).toType();
2806 const builtin_namespace = zcu.namespacePtrUnwrap(builtin_ty.getNamespaceIndex(zcu)).?;
2806 const builtin_namespace = zcu.namespacePtr(builtin_ty.getNamespaceIndex(zcu));
28072807 const stack_trace_nav = builtin_namespace.pub_decls.getKeyAdapted(stack_trace_str, Zcu.Namespace.NameAdapter{ .zcu = zcu }).?;
28082808
28092809 // Sema should have ensured that StackTrace was analyzed.