Commit 3afda4322c34dedc2319701fdfac3505c8d311e9 | zig

src/Compilation.zig+10-4

src/InternPool.zig+201-54

 @@ -34,6 +34,9 @@ src_hash_deps: std.AutoArrayHashMapUnmanaged(TrackedInst.Index, DepEntry.Index),
 /// Dependencies on the value of a Nav.
 /// Value is index into `dep_entries` of the first dependency on this Nav value.
 nav_val_deps: std.AutoArrayHashMapUnmanaged(Nav.Index, DepEntry.Index),
+/// Dependencies on the type of a Nav.
+/// Value is index into `dep_entries` of the first dependency on this Nav value.
+nav_ty_deps: std.AutoArrayHashMapUnmanaged(Nav.Index, DepEntry.Index),
 /// Dependencies on an interned value, either:
 /// * a runtime function (invalidated when its IES changes)
 /// * a container type requiring resolution (invalidated when the type must be recreated at a new index)
 @@ -80,6 +83,7 @@ pub const empty: InternPool = .{
     .file_deps = .empty,
     .src_hash_deps = .empty,
     .nav_val_deps = .empty,
+    .nav_ty_deps = .empty,
     .interned_deps = .empty,
     .namespace_deps = .empty,
     .namespace_name_deps = .empty,
 @@ -371,6 +375,7 @@ pub const AnalUnit = packed struct(u64) {
     pub const Kind = enum(u32) {
         @"comptime",
         nav_val,
+        nav_ty,
         type,
         func,
     };
 @@ -380,6 +385,8 @@ pub const AnalUnit = packed struct(u64) {
         @"comptime": ComptimeUnit.Id,
         /// This `AnalUnit` resolves the value of the given `Nav`.
         nav_val: Nav.Index,
+        /// This `AnalUnit` resolves the type of the given `Nav`.
+        nav_ty: Nav.Index,
         /// This `AnalUnit` resolves the given `struct`/`union`/`enum` type.
         /// Generated tag enums are never used here (they do not undergo type resolution).
         type: InternPool.Index,
 @@ -483,8 +490,20 @@ pub const Nav = struct {
     status: union(enum) {
         /// This `Nav` is pending semantic analysis.
         unresolved,
+        /// The type of this `Nav` is resolved; the value is queued for resolution.
+        type_resolved: struct {
+            type: InternPool.Index,
+            alignment: Alignment,
+            @"linksection": OptionalNullTerminatedString,
+            @"addrspace": std.builtin.AddressSpace,
+            is_const: bool,
+            is_threadlocal: bool,
+            /// This field is whether this `Nav` is a literal `extern` definition.
+            /// It does *not* tell you whether this might alias an extern fn (see #21027).
+            is_extern_decl: bool,
+        },
         /// The value of this `Nav` is resolved.
-        resolved: struct {
+        fully_resolved: struct {
             val: InternPool.Index,
             alignment: Alignment,
             @"linksection": OptionalNullTerminatedString,
 @@ -492,14 +511,81 @@ pub const Nav = struct {
         },
     },
-    /// Asserts that `status == .resolved`.
+    /// Asserts that `status != .unresolved`.
     pub fn typeOf(nav: Nav, ip: *const InternPool) InternPool.Index {
-        return ip.typeOf(nav.status.resolved.val);
+        return switch (nav.status) {
+            .unresolved => unreachable,
+            .type_resolved => |r| r.type,
+            .fully_resolved => |r| ip.typeOf(r.val),
+        };
     }
-    /// Asserts that `status == .resolved`.
+    /// Always returns `null` for `status == .type_resolved`. This function is inteded
-    pub fn isExtern(nav: Nav, ip: *const InternPool) bool {
+    /// to be used by code generation, since semantic analysis will ensure that any `Nav`
-        return ip.indexToKey(nav.status.resolved.val) == .@"extern";
+    /// which is potentially `extern` is fully resolved.
+    /// Asserts that `status != .unresolved`.
+    pub fn getExtern(nav: Nav, ip: *const InternPool) ?Key.Extern {
+        return switch (nav.status) {
+            .unresolved => unreachable,
+            .type_resolved => null,
+            .fully_resolved => |r| switch (ip.indexToKey(r.val)) {
+                .@"extern" => |e| e,
+                else => null,
+            },
+        };
+    }
+    /// Asserts that `status != .unresolved`.
+    pub fn getAddrspace(nav: Nav) std.builtin.AddressSpace {
+        return switch (nav.status) {
+            .unresolved => unreachable,
+            .type_resolved => |r| r.@"addrspace",
+            .fully_resolved => |r| r.@"addrspace",
+        };
+    }
+    /// Asserts that `status != .unresolved`.
+    pub fn getAlignment(nav: Nav) Alignment {
+        return switch (nav.status) {
+            .unresolved => unreachable,
+            .type_resolved => |r| r.alignment,
+            .fully_resolved => |r| r.alignment,
+        };
+    }
+    /// Asserts that `status != .unresolved`.
+    pub fn isThreadlocal(nav: Nav, ip: *const InternPool) bool {
+        return switch (nav.status) {
+            .unresolved => unreachable,
+            .type_resolved => |r| r.is_threadlocal,
+            .fully_resolved => |r| switch (ip.indexToKey(r.val)) {
+                .@"extern" => |e| e.is_threadlocal,
+                .variable => |v| v.is_threadlocal,
+                else => false,
+            },
+        };
+    }
+    /// If this returns `true`, then a pointer to this `Nav` might actually be encoded as a pointer
+    /// to some other `Nav` due to an extern definition or extern alias (see #21027).
+    /// This query is valid on `Nav`s for whom only the type is resolved.
+    /// Asserts that `status != .unresolved`.
+    pub fn isExternOrFn(nav: Nav, ip: *const InternPool) bool {
+        return switch (nav.status) {
+            .unresolved => unreachable,
+            .type_resolved => |r| {
+                if (r.is_extern_decl) return true;
+                const tag = ip.zigTypeTagOrPoison(r.type) catch unreachable;
+                if (tag == .@"fn") return true;
+                return false;
+            },
+            .fully_resolved => |r| {
+                if (ip.indexToKey(r.val) == .@"extern") return true;
+                const tag = ip.zigTypeTagOrPoison(ip.typeOf(r.val)) catch unreachable;
+                if (tag == .@"fn") return true;
+                return false;
+            },
+        };
     }
     /// Get the ZIR instruction corresponding to this `Nav`, used to resolve source locations.
 @@ -509,7 +595,7 @@ pub const Nav = struct {
             return a.zir_index;
         }
         // A `Nav` which does not undergo analysis always has a resolved value.
-        return switch (ip.indexToKey(nav.status.resolved.val)) {
+        return switch (ip.indexToKey(nav.status.fully_resolved.val)) {
             .func => |func| {
                 // Since `analysis` was not populated, this must be an instantiation.
                 // Go up to the generic owner and consult *its* `analysis` field.
 @@ -567,19 +653,22 @@ pub const Nav = struct {
         // The following 1 fields are either both populated, or both `.none`.
         analysis_namespace: OptionalNamespaceIndex,
         analysis_zir_index: TrackedInst.Index.Optional,
-        /// Populated only if `bits.status == .resolved`.
+        /// Populated only if `bits.status != .unresolved`.
-        val: InternPool.Index,
+        type_or_val: InternPool.Index,
-        /// Populated only if `bits.status == .resolved`.
+        /// Populated only if `bits.status != .unresolved`.
         @"linksection": OptionalNullTerminatedString,
         bits: Bits,
         const Bits = packed struct(u16) {
-            status: enum(u1) { unresolved, resolved },
+            status: enum(u2) { unresolved, type_resolved, fully_resolved, type_resolved_extern_decl },
-            /// Populated only if `bits.status == .resolved`.
+            /// Populated only if `bits.status != .unresolved`.
             alignment: Alignment,
-            /// Populated only if `bits.status == .resolved`.
+            /// Populated only if `bits.status != .unresolved`.
             @"addrspace": std.builtin.AddressSpace,
-            _: u3 = 0,
+            /// Populated only if `bits.status == .type_resolved`.
+            is_const: bool,
+            /// Populated only if `bits.status == .type_resolved`.
+            is_threadlocal: bool,
             is_usingnamespace: bool,
         };
 @@ -597,8 +686,17 @@ pub const Nav = struct {
                 .is_usingnamespace = repr.bits.is_usingnamespace,
                 .status = switch (repr.bits.status) {
                     .unresolved => .unresolved,
-                    .resolved => .{ .resolved = .{
+                    .type_resolved, .type_resolved_extern_decl => .{ .type_resolved = .{
-                        .val = repr.val,
+                        .type = repr.type_or_val,
+                        .alignment = repr.bits.alignment,
+                        .@"linksection" = repr.@"linksection",
+                        .@"addrspace" = repr.bits.@"addrspace",
+                        .is_const = repr.bits.is_const,
+                        .is_threadlocal = repr.bits.is_threadlocal,
+                        .is_extern_decl = repr.bits.status == .type_resolved_extern_decl,
+                    } },
+                    .fully_resolved => .{ .fully_resolved = .{
+                        .val = repr.type_or_val,
                         .alignment = repr.bits.alignment,
                         .@"linksection" = repr.@"linksection",
                         .@"addrspace" = repr.bits.@"addrspace",
 @@ -616,13 +714,15 @@ pub const Nav = struct {
             .fqn = nav.fqn,
             .analysis_namespace = if (nav.analysis) |a| a.namespace.toOptional() else .none,
             .analysis_zir_index = if (nav.analysis) |a| a.zir_index.toOptional() else .none,
-            .val = switch (nav.status) {
+            .type_or_val = switch (nav.status) {
                 .unresolved => .none,
-                .resolved => |r| r.val,
+                .type_resolved => |r| r.type,
+                .fully_resolved => |r| r.val,
             },
             .@"linksection" = switch (nav.status) {
                 .unresolved => .none,
-                .resolved => |r| r.@"linksection",
+                .type_resolved => |r| r.@"linksection",
+                .fully_resolved => |r| r.@"linksection",
             },
             .bits = switch (nav.status) {
                 .unresolved => .{
 @@ -630,12 +730,24 @@ pub const Nav = struct {
                     .alignment = .none,
                     .@"addrspace" = .generic,
                     .is_usingnamespace = nav.is_usingnamespace,
+                    .is_const = false,
+                    .is_threadlocal = false,
+                },
+                .type_resolved => |r| .{
+                    .status = if (r.is_extern_decl) .type_resolved_extern_decl else .type_resolved,
+                    .alignment = r.alignment,
+                    .@"addrspace" = r.@"addrspace",
+                    .is_usingnamespace = nav.is_usingnamespace,
+                    .is_const = r.is_const,
+                    .is_threadlocal = r.is_threadlocal,
                 },
-                .resolved => |r| .{
+                .fully_resolved => |r| .{
-                    .status = .resolved,
+                    .status = .fully_resolved,
                     .alignment = r.alignment,
                     .@"addrspace" = r.@"addrspace",
                     .is_usingnamespace = nav.is_usingnamespace,
+                    .is_const = false,
+                    .is_threadlocal = false,
                 },
             },
         };
 @@ -646,6 +758,7 @@ pub const Dependee = union(enum) {
     file: FileIndex,
     src_hash: TrackedInst.Index,
     nav_val: Nav.Index,
+    nav_ty: Nav.Index,
     interned: Index,
     namespace: TrackedInst.Index,
     namespace_name: NamespaceNameKey,
 @@ -695,6 +808,7 @@ pub fn dependencyIterator(ip: *const InternPool, dependee: Dependee) DependencyI
         .file => |x| ip.file_deps.get(x),
         .src_hash => |x| ip.src_hash_deps.get(x),
         .nav_val => |x| ip.nav_val_deps.get(x),
+        .nav_ty => |x| ip.nav_ty_deps.get(x),
         .interned => |x| ip.interned_deps.get(x),
         .namespace => |x| ip.namespace_deps.get(x),
         .namespace_name => |x| ip.namespace_name_deps.get(x),
 @@ -732,6 +846,7 @@ pub fn addDependency(ip: *InternPool, gpa: Allocator, depender: AnalUnit, depend
                 .file => ip.file_deps,
                 .src_hash => ip.src_hash_deps,
                 .nav_val => ip.nav_val_deps,
+                .nav_ty => ip.nav_ty_deps,
                 .interned => ip.interned_deps,
                 .namespace => ip.namespace_deps,
                 .namespace_name => ip.namespace_name_deps,
 @@ -2079,36 +2194,36 @@ pub const Key = union(enum) {
             return @atomicLoad(FuncAnalysis, func.analysisPtr(ip), .unordered);
         }
-        pub fn setAnalysisState(func: Func, ip: *InternPool, state: FuncAnalysis.State) void {
+        pub fn setCallsOrAwaitsErrorableFn(func: Func, ip: *InternPool, value: bool) void {
             const extra_mutex = &ip.getLocal(func.tid).mutate.extra.mutex;
             extra_mutex.lock();
             defer extra_mutex.unlock();
             const analysis_ptr = func.analysisPtr(ip);
             var analysis = analysis_ptr.*;
-            analysis.state = state;
+            analysis.calls_or_awaits_errorable_fn = value;
             @atomicStore(FuncAnalysis, analysis_ptr, analysis, .release);
         }
-        pub fn setCallsOrAwaitsErrorableFn(func: Func, ip: *InternPool, value: bool) void {
+        pub fn setBranchHint(func: Func, ip: *InternPool, hint: std.builtin.BranchHint) void {
             const extra_mutex = &ip.getLocal(func.tid).mutate.extra.mutex;
             extra_mutex.lock();
             defer extra_mutex.unlock();
             const analysis_ptr = func.analysisPtr(ip);
             var analysis = analysis_ptr.*;
-            analysis.calls_or_awaits_errorable_fn = value;
+            analysis.branch_hint = hint;
             @atomicStore(FuncAnalysis, analysis_ptr, analysis, .release);
         }
-        pub fn setBranchHint(func: Func, ip: *InternPool, hint: std.builtin.BranchHint) void {
+        pub fn setAnalyzed(func: Func, ip: *InternPool) void {
             const extra_mutex = &ip.getLocal(func.tid).mutate.extra.mutex;
             extra_mutex.lock();
             defer extra_mutex.unlock();
             const analysis_ptr = func.analysisPtr(ip);
             var analysis = analysis_ptr.*;
-            analysis.branch_hint = hint;
+            analysis.is_analyzed = true;
             @atomicStore(FuncAnalysis, analysis_ptr, analysis, .release);
         }
 @@ -5755,7 +5870,7 @@ pub const Tag = enum(u8) {
 /// equality or hashing, except for `inferred_error_set` which is considered
 /// to be part of the type of the function.
 pub const FuncAnalysis = packed struct(u32) {
-    state: State,
+    is_analyzed: bool,
     branch_hint: std.builtin.BranchHint,
     is_noinline: bool,
     calls_or_awaits_errorable_fn: bool,
 @@ -5763,20 +5878,7 @@ pub const FuncAnalysis = packed struct(u32) {
     inferred_error_set: bool,
     disable_instrumentation: bool,
-    _: u23 = 0,
+    _: u24 = 0,
-    pub const State = enum(u2) {
-        /// The runtime function has never been referenced.
-        /// As such, it has never been analyzed, nor is it queued for analysis.
-        unreferenced,
-        /// The runtime function has been referenced, but has not yet been analyzed.
-        /// Its semantic analysis is queued.
-        queued,
-        /// The runtime function has been (or is currently being) semantically analyzed.
-        /// To know if analysis succeeded, consult `zcu.[transitive_]failed_analysis`.
-        /// To know if analysis is up-to-date, consult `zcu.[potentially_]outdated`.
-        analyzed,
-    };
 };
 pub const Bytes = struct {
 @@ -6419,6 +6521,7 @@ pub fn deinit(ip: *InternPool, gpa: Allocator) void {
     ip.file_deps.deinit(gpa);
     ip.src_hash_deps.deinit(gpa);
     ip.nav_val_deps.deinit(gpa);
+    ip.nav_ty_deps.deinit(gpa);
     ip.interned_deps.deinit(gpa);
     ip.namespace_deps.deinit(gpa);
     ip.namespace_name_deps.deinit(gpa);
 @@ -6875,8 +6978,8 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
                 .is_threadlocal = extra.flags.is_threadlocal,
                 .is_weak_linkage = extra.flags.is_weak_linkage,
                 .is_dll_import = extra.flags.is_dll_import,
-                .alignment = nav.status.resolved.alignment,
+                .alignment = nav.status.fully_resolved.alignment,
-                .@"addrspace" = nav.status.resolved.@"addrspace",
+                .@"addrspace" = nav.status.fully_resolved.@"addrspace",
                 .zir_index = extra.zir_index,
                 .owner_nav = extra.owner_nav,
             } };
 @@ -8794,7 +8897,7 @@ pub fn getFuncDecl(
     const func_decl_extra_index = addExtraAssumeCapacity(extra, Tag.FuncDecl{
         .analysis = .{
-            .state = .unreferenced,
+            .is_analyzed = false,
             .branch_hint = .none,
             .is_noinline = key.is_noinline,
             .calls_or_awaits_errorable_fn = false,
 @@ -8903,7 +9006,7 @@ pub fn getFuncDeclIes(
     const func_decl_extra_index = addExtraAssumeCapacity(extra, Tag.FuncDecl{
         .analysis = .{
-            .state = .unreferenced,
+            .is_analyzed = false,
             .branch_hint = .none,
             .is_noinline = key.is_noinline,
             .calls_or_awaits_errorable_fn = false,
 @@ -9099,7 +9202,7 @@ pub fn getFuncInstance(
     const func_extra_index = addExtraAssumeCapacity(extra, Tag.FuncInstance{
         .analysis = .{
-            .state = .unreferenced,
+            .is_analyzed = false,
             .branch_hint = .none,
             .is_noinline = arg.is_noinline,
             .calls_or_awaits_errorable_fn = false,
 @@ -9197,7 +9300,7 @@ pub fn getFuncInstanceIes(
     const func_extra_index = addExtraAssumeCapacity(extra, Tag.FuncInstance{
         .analysis = .{
-            .state = .unreferenced,
+            .is_analyzed = false,
             .branch_hint = .none,
             .is_noinline = arg.is_noinline,
             .calls_or_awaits_errorable_fn = false,
 @@ -9316,9 +9419,9 @@ fn finishFuncInstance(
         .name = nav_name,
         .fqn = try ip.namespacePtr(fn_namespace).internFullyQualifiedName(ip, gpa, tid, nav_name),
         .val = func_index,
-        .alignment = fn_owner_nav.status.resolved.alignment,
+        .alignment = fn_owner_nav.status.fully_resolved.alignment,
-        .@"linksection" = fn_owner_nav.status.resolved.@"linksection",
+        .@"linksection" = fn_owner_nav.status.fully_resolved.@"linksection",
-        .@"addrspace" = fn_owner_nav.status.resolved.@"addrspace",
+        .@"addrspace" = fn_owner_nav.status.fully_resolved.@"addrspace",
     });
     // Populate the owner_nav field which was left undefined until now.
 @@ -11030,7 +11133,7 @@ pub fn createNav(
         .name = opts.name,
         .fqn = opts.fqn,
         .analysis = null,
-        .status = .{ .resolved = .{
+        .status = .{ .fully_resolved = .{
             .val = opts.val,
             .alignment = opts.alignment,
             .@"linksection" = opts.@"linksection",
 @@ -11077,6 +11180,50 @@ pub fn createDeclNav(
     return nav;
 }
+/// Resolve the type of a `Nav` with an analysis owner.
+/// If its status is already `resolved`, the old value is discarded.
+pub fn resolveNavType(
+    ip: *InternPool,
+    nav: Nav.Index,
+    resolved: struct {
+        type: InternPool.Index,
+        alignment: Alignment,
+        @"linksection": OptionalNullTerminatedString,
+        @"addrspace": std.builtin.AddressSpace,
+        is_const: bool,
+        is_threadlocal: bool,
+        is_extern_decl: bool,
+    },
+) void {
+    const unwrapped = nav.unwrap(ip);
+    const local = ip.getLocal(unwrapped.tid);
+    local.mutate.extra.mutex.lock();
+    defer local.mutate.extra.mutex.unlock();
+    const navs = local.shared.navs.view();
+    const nav_analysis_namespace = navs.items(.analysis_namespace);
+    const nav_analysis_zir_index = navs.items(.analysis_zir_index);
+    const nav_types = navs.items(.type_or_val);
+    const nav_linksections = navs.items(.@"linksection");
+    const nav_bits = navs.items(.bits);
+    assert(nav_analysis_namespace[unwrapped.index] != .none);
+    assert(nav_analysis_zir_index[unwrapped.index] != .none);
+    @atomicStore(InternPool.Index, &nav_types[unwrapped.index], resolved.type, .release);
+    @atomicStore(OptionalNullTerminatedString, &nav_linksections[unwrapped.index], resolved.@"linksection", .release);
+    var bits = nav_bits[unwrapped.index];
+    bits.status = if (resolved.is_extern_decl) .type_resolved_extern_decl else .type_resolved;
+    bits.alignment = resolved.alignment;
+    bits.@"addrspace" = resolved.@"addrspace";
+    bits.is_const = resolved.is_const;
+    bits.is_threadlocal = resolved.is_threadlocal;
+    @atomicStore(Nav.Repr.Bits, &nav_bits[unwrapped.index], bits, .release);
+}
 /// Resolve the value of a `Nav` with an analysis owner.
 /// If its status is already `resolved`, the old value is discarded.
 pub fn resolveNavValue(
 @@ -11099,7 +11246,7 @@ pub fn resolveNavValue(
     const nav_analysis_namespace = navs.items(.analysis_namespace);
     const nav_analysis_zir_index = navs.items(.analysis_zir_index);
-    const nav_vals = navs.items(.val);
+    const nav_vals = navs.items(.type_or_val);
     const nav_linksections = navs.items(.@"linksection");
     const nav_bits = navs.items(.bits);
 @@ -11110,7 +11257,7 @@ pub fn resolveNavValue(
     @atomicStore(OptionalNullTerminatedString, &nav_linksections[unwrapped.index], resolved.@"linksection", .release);
     var bits = nav_bits[unwrapped.index];
-    bits.status = .resolved;
+    bits.status = .fully_resolved;
     bits.alignment = resolved.alignment;
     bits.@"addrspace" = resolved.@"addrspace";
     @atomicStore(Nav.Repr.Bits, &nav_bits[unwrapped.index], bits, .release);

src/Sema.zig+157-46

...	@@ -6495,9 +6495,9 @@ pub fn analyzeExport(	...	@@ -6495,9 +6495,9 @@ pub fn analyzeExport(
6495	if (options.linkage == .internal)	6495	if (options.linkage == .internal)
6496	return;	6496	return;
6497		6497
6498	try sema.ensureNavResolved(src, orig_nav_index);	6498	try sema.ensureNavResolved(src, orig_nav_index, .fully);
6499		6499
6500	const exported_nav_index = switch (ip.indexToKey(ip.getNav(orig_nav_index).status.resolved.val)) {	6500	const exported_nav_index = switch (ip.indexToKey(ip.getNav(orig_nav_index).status.fully_resolved.val)) {
6501	.variable => \|v\| v.owner_nav,	6501	.variable => \|v\| v.owner_nav,
6502	.@"extern" => \|e\| e.owner_nav,	6502	.@"extern" => \|e\| e.owner_nav,
6503	.func => \|f\| f.owner_nav,	6503	.func => \|f\| f.owner_nav,
...	@@ -6520,7 +6520,7 @@ pub fn analyzeExport(	...	@@ -6520,7 +6520,7 @@ pub fn analyzeExport(
6520	}	6520	}
6521		6521
6522	// TODO: some backends might support re-exporting extern decls	6522	// TODO: some backends might support re-exporting extern decls
6523	if (exported_nav.isExtern(ip)) {	6523	if (exported_nav.getExtern(ip) != null) {
6524	return sema.fail(block, src, "export target cannot be extern", .{});	6524	return sema.fail(block, src, "export target cannot be extern", .{});
6525	}	6525	}
6526		6526
...	@@ -6542,6 +6542,7 @@ fn zirDisableInstrumentation(sema: *Sema) CompileError!void {	...	@@ -6542,6 +6542,7 @@ fn zirDisableInstrumentation(sema: *Sema) CompileError!void {
6542	.func => \|func\| func,	6542	.func => \|func\| func,
6543	.@"comptime",	6543	.@"comptime",
6544	.nav_val,	6544	.nav_val,
		6545	.nav_ty,
6545	.type,	6546	.type,
6546	=> return, // does nothing outside a function	6547	=> return, // does nothing outside a function
6547	};	6548	};
...	@@ -6854,8 +6855,8 @@ fn lookupInNamespace(	...	@@ -6854,8 +6855,8 @@ fn lookupInNamespace(
6854	}	6855	}
6855		6856
6856	for (usingnamespaces.items) \|sub_ns_nav\| {	6857	for (usingnamespaces.items) \|sub_ns_nav\| {
6857	try sema.ensureNavResolved(src, sub_ns_nav);	6858	try sema.ensureNavResolved(src, sub_ns_nav, .fully);
6858	const sub_ns_ty = Type.fromInterned(ip.getNav(sub_ns_nav).status.resolved.val);	6859	const sub_ns_ty = Type.fromInterned(ip.getNav(sub_ns_nav).status.fully_resolved.val);
6859	const sub_ns = zcu.namespacePtr(sub_ns_ty.getNamespaceIndex(zcu));	6860	const sub_ns = zcu.namespacePtr(sub_ns_ty.getNamespaceIndex(zcu));
6860	try checked_namespaces.put(gpa, sub_ns, {});	6861	try checked_namespaces.put(gpa, sub_ns, {});
6861	}	6862	}
...	@@ -6865,7 +6866,7 @@ fn lookupInNamespace(	...	@@ -6865,7 +6866,7 @@ fn lookupInNamespace(
6865	ignore_self: {	6866	ignore_self: {
6866	const skip_nav = switch (sema.owner.unwrap()) {	6867	const skip_nav = switch (sema.owner.unwrap()) {
6867	.@"comptime", .type, .func => break :ignore_self,	6868	.@"comptime", .type, .func => break :ignore_self,
6868	.nav_val => \|nav\| nav,	6869	.nav_ty, .nav_val => \|nav\| nav,
6869	};	6870	};
6870	var i: usize = 0;	6871	var i: usize = 0;
6871	while (i < candidates.items.len) {	6872	while (i < candidates.items.len) {
...	@@ -7125,7 +7126,7 @@ fn zirCall(	...	@@ -7125,7 +7126,7 @@ fn zirCall(
7125	const call_inst = try sema.analyzeCall(block, func, func_ty, callee_src, call_src, modifier, ensure_result_used, args_info, call_dbg_node, .call);	7126	const call_inst = try sema.analyzeCall(block, func, func_ty, callee_src, call_src, modifier, ensure_result_used, args_info, call_dbg_node, .call);
7126		7127
7127	switch (sema.owner.unwrap()) {	7128	switch (sema.owner.unwrap()) {
7128	.@"comptime", .type, .nav_val => input_is_error = false,	7129	.@"comptime", .type, .nav_ty, .nav_val => input_is_error = false,
7129	.func => \|owner_func\| if (!zcu.intern_pool.funcAnalysisUnordered(owner_func).calls_or_awaits_errorable_fn) {	7130	.func => \|owner_func\| if (!zcu.intern_pool.funcAnalysisUnordered(owner_func).calls_or_awaits_errorable_fn) {
7130	// No errorable fn actually called; we have no error return trace	7131	// No errorable fn actually called; we have no error return trace
7131	input_is_error = false;	7132	input_is_error = false;
...	@@ -7686,12 +7687,13 @@ fn analyzeCall(	...	@@ -7686,12 +7687,13 @@ fn analyzeCall(
7686	.ptr => \|ptr\| blk: {	7687	.ptr => \|ptr\| blk: {
7687	switch (ptr.base_addr) {	7688	switch (ptr.base_addr) {
7688	.nav => \|nav_index\| if (ptr.byte_offset == 0) {	7689	.nav => \|nav_index\| if (ptr.byte_offset == 0) {
		7690	try sema.ensureNavResolved(call_src, nav_index, .fully);
7689	const nav = ip.getNav(nav_index);	7691	const nav = ip.getNav(nav_index);
7690	if (nav.isExtern(ip))	7692	if (nav.getExtern(ip) != null)
7691	return sema.fail(block, call_src, "{s} call of extern function pointer", .{	7693	return sema.fail(block, call_src, "{s} call of extern function pointer", .{
7692	if (is_comptime_call) "comptime" else "inline",	7694	if (is_comptime_call) "comptime" else "inline",
7693	});	7695	});
7694	break :blk nav.status.resolved.val;	7696	break :blk nav.status.fully_resolved.val;
7695	},	7697	},
7696	else => {},	7698	else => {},
7697	}	7699	}
...	@@ -8007,7 +8009,7 @@ fn analyzeCall(	...	@@ -8007,7 +8009,7 @@ fn analyzeCall(
8007	if (call_dbg_node) \|some\| try sema.zirDbgStmt(block, some);	8009	if (call_dbg_node) \|some\| try sema.zirDbgStmt(block, some);
8008		8010
8009	switch (sema.owner.unwrap()) {	8011	switch (sema.owner.unwrap()) {
8010	.@"comptime", .nav_val, .type => {},	8012	.@"comptime", .nav_ty, .nav_val, .type => {},
8011	.func => \|owner_func\| if (Type.fromInterned(func_ty_info.return_type).isError(zcu)) {	8013	.func => \|owner_func\| if (Type.fromInterned(func_ty_info.return_type).isError(zcu)) {
8012	ip.funcSetCallsOrAwaitsErrorableFn(owner_func);	8014	ip.funcSetCallsOrAwaitsErrorableFn(owner_func);
8013	},	8015	},
...	@@ -8046,7 +8048,10 @@ fn analyzeCall(	...	@@ -8046,7 +8048,10 @@ fn analyzeCall(
8046	switch (zcu.intern_pool.indexToKey(func_val.toIntern())) {	8048	switch (zcu.intern_pool.indexToKey(func_val.toIntern())) {
8047	.func => break :skip_safety,	8049	.func => break :skip_safety,
8048	.ptr => \|ptr\| if (ptr.byte_offset == 0) switch (ptr.base_addr) {	8050	.ptr => \|ptr\| if (ptr.byte_offset == 0) switch (ptr.base_addr) {
8049	.nav => \|nav\| if (!ip.getNav(nav).isExtern(ip)) break :skip_safety,	8051	.nav => \|nav\| {
		8052	try sema.ensureNavResolved(call_src, nav, .fully);
		8053	if (ip.getNav(nav).getExtern(ip) == null) break :skip_safety;
		8054	},
8050	else => {},	8055	else => {},
8051	},	8056	},
8052	else => {},	8057	else => {},
...	@@ -8243,7 +8248,7 @@ fn instantiateGenericCall(	...	@@ -8243,7 +8248,7 @@ fn instantiateGenericCall(
8243	});	8248	});
8244	const generic_owner = switch (zcu.intern_pool.indexToKey(func_val.toIntern())) {	8249	const generic_owner = switch (zcu.intern_pool.indexToKey(func_val.toIntern())) {
8245	.func => func_val.toIntern(),	8250	.func => func_val.toIntern(),
8246	.ptr => \|ptr\| ip.getNav(ptr.base_addr.nav).status.resolved.val,	8251	.ptr => \|ptr\| ip.getNav(ptr.base_addr.nav).status.fully_resolved.val,
8247	else => unreachable,	8252	else => unreachable,
8248	};	8253	};
8249	const generic_owner_func = zcu.intern_pool.indexToKey(generic_owner).func;	8254	const generic_owner_func = zcu.intern_pool.indexToKey(generic_owner).func;
...	@@ -8471,7 +8476,7 @@ fn instantiateGenericCall(	...	@@ -8471,7 +8476,7 @@ fn instantiateGenericCall(
8471	if (call_dbg_node) \|some\| try sema.zirDbgStmt(block, some);	8476	if (call_dbg_node) \|some\| try sema.zirDbgStmt(block, some);
8472		8477
8473	switch (sema.owner.unwrap()) {	8478	switch (sema.owner.unwrap()) {
8474	.@"comptime", .nav_val, .type => {},	8479	.@"comptime", .nav_ty, .nav_val, .type => {},
8475	.func => \|owner_func\| if (Type.fromInterned(func_ty_info.return_type).isError(zcu)) {	8480	.func => \|owner_func\| if (Type.fromInterned(func_ty_info.return_type).isError(zcu)) {
8476	ip.funcSetCallsOrAwaitsErrorableFn(owner_func);	8481	ip.funcSetCallsOrAwaitsErrorableFn(owner_func);
8477	},	8482	},
...	@@ -19311,8 +19316,8 @@ fn typeInfoNamespaceDecls(	...	@@ -19311,8 +19316,8 @@ fn typeInfoNamespaceDecls(
19311	if (zcu.analysis_in_progress.contains(.wrap(.{ .nav_val = nav }))) {	19316	if (zcu.analysis_in_progress.contains(.wrap(.{ .nav_val = nav }))) {
19312	continue;	19317	continue;
19313	}	19318	}
19314	try sema.ensureNavResolved(src, nav);	19319	try sema.ensureNavResolved(src, nav, .fully);
19315	const namespace_ty = Type.fromInterned(ip.getNav(nav).status.resolved.val);	19320	const namespace_ty = Type.fromInterned(ip.getNav(nav).status.fully_resolved.val);
19316	try sema.typeInfoNamespaceDecls(block, src, namespace_ty.getNamespaceIndex(zcu).toOptional(), declaration_ty, decl_vals, seen_namespaces);	19321	try sema.typeInfoNamespaceDecls(block, src, namespace_ty.getNamespaceIndex(zcu).toOptional(), declaration_ty, decl_vals, seen_namespaces);
19317	}	19322	}
19318	}	19323	}
...	@@ -21602,7 +21607,7 @@ fn getErrorReturnTrace(sema: Sema, block: Block) CompileError!Air.Inst.Ref {	...	@@ -21602,7 +21607,7 @@ fn getErrorReturnTrace(sema: Sema, block: Block) CompileError!Air.Inst.Ref {
21602	.func => \|func\| if (ip.funcAnalysisUnordered(func).calls_or_awaits_errorable_fn and block.ownerModule().error_tracing) {	21607	.func => \|func\| if (ip.funcAnalysisUnordered(func).calls_or_awaits_errorable_fn and block.ownerModule().error_tracing) {
21603	return block.addTy(.err_return_trace, opt_ptr_stack_trace_ty);	21608	return block.addTy(.err_return_trace, opt_ptr_stack_trace_ty);
21604	},	21609	},
21605	.@"comptime", .nav_val, .type => {},	21610	.@"comptime", .nav_ty, .nav_val, .type => {},
21606	}	21611	}
21607	return Air.internedToRef(try pt.intern(.{ .opt = .{	21612	return Air.internedToRef(try pt.intern(.{ .opt = .{
21608	.ty = opt_ptr_stack_trace_ty.toIntern(),	21613	.ty = opt_ptr_stack_trace_ty.toIntern(),
...	@@ -27086,7 +27091,7 @@ fn zirBuiltinExtern(	...	@@ -27086,7 +27091,7 @@ fn zirBuiltinExtern(
27086	.zir_index = switch (sema.owner.unwrap()) {	27091	.zir_index = switch (sema.owner.unwrap()) {
27087	.@"comptime" => \|cu\| ip.getComptimeUnit(cu).zir_index,	27092	.@"comptime" => \|cu\| ip.getComptimeUnit(cu).zir_index,
27088	.type => \|owner_ty\| Type.fromInterned(owner_ty).typeDeclInst(zcu).?,	27093	.type => \|owner_ty\| Type.fromInterned(owner_ty).typeDeclInst(zcu).?,
27089	.nav_val => \|nav\| ip.getNav(nav).analysis.?.zir_index,	27094	.nav_ty, .nav_val => \|nav\| ip.getNav(nav).analysis.?.zir_index,
27090	.func => \|func\| zir_index: {	27095	.func => \|func\| zir_index: {
27091	const func_info = zcu.funcInfo(func);	27096	const func_info = zcu.funcInfo(func);
27092	const owner_func_info = if (func_info.generic_owner != .none) owner: {	27097	const owner_func_info = if (func_info.generic_owner != .none) owner: {
...	@@ -27741,7 +27746,7 @@ fn preparePanicId(sema: Sema, block: Block, src: LazySrcLoc, panic_id: Zcu.Pan	...	@@ -27741,7 +27746,7 @@ fn preparePanicId(sema: Sema, block: Block, src: LazySrcLoc, panic_id: Zcu.Pan
27741	error.GenericPoison, error.ComptimeReturn, error.ComptimeBreak => unreachable,	27746	error.GenericPoison, error.ComptimeReturn, error.ComptimeBreak => unreachable,
27742	error.OutOfMemory => \|e\| return e,	27747	error.OutOfMemory => \|e\| return e,
27743	}).?;	27748	}).?;
27744	try sema.ensureNavResolved(src, msg_nav_index);	27749	try sema.ensureNavResolved(src, msg_nav_index, .fully);
27745	zcu.panic_messages[@intFromEnum(panic_id)] = msg_nav_index.toOptional();	27750	zcu.panic_messages[@intFromEnum(panic_id)] = msg_nav_index.toOptional();
27746	return msg_nav_index;	27751	return msg_nav_index;
27747	}	27752	}
...	@@ -32648,21 +32653,29 @@ fn addTypeReferenceEntry(	...	@@ -32648,21 +32653,29 @@ fn addTypeReferenceEntry(
32648	try zcu.addTypeReference(sema.owner, referenced_type, src);	32653	try zcu.addTypeReference(sema.owner, referenced_type, src);
32649	}	32654	}
32650		32655
32651	pub fn ensureNavResolved(sema: *Sema, src: LazySrcLoc, nav_index: InternPool.Nav.Index) CompileError!void {	32656	pub fn ensureNavResolved(sema: *Sema, src: LazySrcLoc, nav_index: InternPool.Nav.Index, kind: enum { type, fully }) CompileError!void {
32652	const pt = sema.pt;	32657	const pt = sema.pt;
32653	const zcu = pt.zcu;	32658	const zcu = pt.zcu;
32654	const ip = &zcu.intern_pool;	32659	const ip = &zcu.intern_pool;
32655		32660
32656	const nav = ip.getNav(nav_index);	32661	const nav = ip.getNav(nav_index);
32657	if (nav.analysis == null) {	32662	if (nav.analysis == null) {
32658	assert(nav.status == .resolved);	32663	assert(nav.status == .fully_resolved);
32659	return;	32664	return;
32660	}	32665	}
32661		32666
		32667	try sema.declareDependency(switch (kind) {
		32668	.type => .{ .nav_ty = nav_index },
		32669	.fully => .{ .nav_val = nav_index },
		32670	});
		32671
32662	// Note that even if `nav.status == .resolved`, we must still trigger `ensureNavValUpToDate`	32672	// Note that even if `nav.status == .resolved`, we must still trigger `ensureNavValUpToDate`
32663	// to make sure the value is up-to-date on incremental updates.	32673	// to make sure the value is up-to-date on incremental updates.
32664		32674
32665	const anal_unit: AnalUnit = .wrap(.{ .nav_val = nav_index });	32675	const anal_unit: AnalUnit = .wrap(switch (kind) {
		32676	.type => .{ .nav_ty = nav_index },
		32677	.fully => .{ .nav_val = nav_index },
		32678	});
32666	try sema.addReferenceEntry(src, anal_unit);	32679	try sema.addReferenceEntry(src, anal_unit);
32667		32680
32668	if (zcu.analysis_in_progress.contains(anal_unit)) {	32681	if (zcu.analysis_in_progress.contains(anal_unit)) {
...	@@ -32672,7 +32685,13 @@ pub fn ensureNavResolved(sema: *Sema, src: LazySrcLoc, nav_index: InternPool.Nav	...	@@ -32672,7 +32685,13 @@ pub fn ensureNavResolved(sema: *Sema, src: LazySrcLoc, nav_index: InternPool.Nav
32672	}, "dependency loop detected", .{}));	32685	}, "dependency loop detected", .{}));
32673	}	32686	}
32674		32687
32675	return pt.ensureNavValUpToDate(nav_index);	32688	switch (kind) {
		32689	.type => {
		32690	try zcu.ensureNavValAnalysisQueued(nav_index);
		32691	return pt.ensureNavTypeUpToDate(nav_index);
		32692	},
		32693	.fully => return pt.ensureNavValUpToDate(nav_index),
		32694	}
32676	}	32695	}
32677		32696
32678	fn optRefValue(sema: *Sema, opt_val: ?Value) !Value {	32697	fn optRefValue(sema: *Sema, opt_val: ?Value) !Value {
...	@@ -32691,36 +32710,44 @@ fn analyzeNavRef(sema: *Sema, src: LazySrcLoc, nav_index: InternPool.Nav.Index)	...	@@ -32691,36 +32710,44 @@ fn analyzeNavRef(sema: *Sema, src: LazySrcLoc, nav_index: InternPool.Nav.Index)
32691	return sema.analyzeNavRefInner(src, nav_index, true);	32710	return sema.analyzeNavRefInner(src, nav_index, true);
32692	}	32711	}
32693		32712
32694	/// Analyze a reference to the `Nav` at the given index. Ensures the underlying `Nav` is analyzed, but	32713	/// Analyze a reference to the `Nav` at the given index. Ensures the underlying `Nav` is analyzed.
32695	/// only triggers analysis for function bodies if `analyze_fn_body` is true. If it's possible for a	32714	/// If this pointer will be used directly, `is_ref` must be `true`.
32696	/// decl_ref to end up in runtime code, the function body must be analyzed: `analyzeNavRef` wraps	32715	/// If this pointer will be immediately loaded (i.e. a `decl_val` instruction), `is_ref` must be `false`.
32697	/// this function with `analyze_fn_body` set to true.	32716	fn analyzeNavRefInner(sema: *Sema, src: LazySrcLoc, orig_nav_index: InternPool.Nav.Index, is_ref: bool) CompileError!Air.Inst.Ref {
32698	fn analyzeNavRefInner(sema: *Sema, src: LazySrcLoc, orig_nav_index: InternPool.Nav.Index, analyze_fn_body: bool) CompileError!Air.Inst.Ref {
32699	const pt = sema.pt;	32717	const pt = sema.pt;
32700	const zcu = pt.zcu;	32718	const zcu = pt.zcu;
32701	const ip = &zcu.intern_pool;	32719	const ip = &zcu.intern_pool;
32702		32720
32703	// TODO: if this is a `decl_ref` of a non-variable Nav, only depend on Nav type	32721	try sema.ensureNavResolved(src, orig_nav_index, if (is_ref) .type else .fully);
32704	try sema.declareDependency(.{ .nav_val = orig_nav_index });
32705	try sema.ensureNavResolved(src, orig_nav_index);
32706		32722
32707	const nav_val = zcu.navValue(orig_nav_index);	32723	const nav_index = nav: {
32708	const nav_index, const is_const = switch (ip.indexToKey(nav_val.toIntern())) {	32724	if (ip.getNav(orig_nav_index).isExternOrFn(ip)) {
32709	.variable => \|v\| .{ v.owner_nav, false },	32725	// Getting a pointer to this `Nav` might mean we actually get a pointer to something else!
32710	.func => \|f\| .{ f.owner_nav, true },	32726	// We need to resolve the value to know for sure.
32711	.@"extern" => \|e\| .{ e.owner_nav, e.is_const },	32727	if (is_ref) try sema.ensureNavResolved(src, orig_nav_index, .fully);
32712	else => .{ orig_nav_index, true },	32728	switch (ip.indexToKey(ip.getNav(orig_nav_index).status.fully_resolved.val)) {
		32729	.func => \|f\| break :nav f.owner_nav,
		32730	.@"extern" => \|e\| break :nav e.owner_nav,
		32731	else => {},
		32732	}
		32733	}
		32734	break :nav orig_nav_index;
		32735	};
		32736
		32737	const ty, const alignment, const @"addrspace", const is_const = switch (ip.getNav(nav_index).status) {
		32738	.unresolved => unreachable,
		32739	.type_resolved => \|r\| .{ r.type, r.alignment, r.@"addrspace", r.is_const },
		32740	.fully_resolved => \|r\| .{ ip.typeOf(r.val), r.alignment, r.@"addrspace", zcu.navValIsConst(r.val) },
32713	};	32741	};
32714	const nav_info = ip.getNav(nav_index).status.resolved;
32715	const ptr_ty = try pt.ptrTypeSema(.{	32742	const ptr_ty = try pt.ptrTypeSema(.{
32716	.child = nav_val.typeOf(zcu).toIntern(),	32743	.child = ty,
32717	.flags = .{	32744	.flags = .{
32718	.alignment = nav_info.alignment,	32745	.alignment = alignment,
32719	.is_const = is_const,	32746	.is_const = is_const,
32720	.address_space = nav_info.@"addrspace",	32747	.address_space = @"addrspace",
32721	},	32748	},
32722	});	32749	});
32723	if (analyze_fn_body) {	32750	if (is_ref) {
32724	try sema.maybeQueueFuncBodyAnalysis(src, nav_index);	32751	try sema.maybeQueueFuncBodyAnalysis(src, nav_index);
32725	}	32752	}
32726	return Air.internedToRef((try pt.intern(.{ .ptr = .{	32753	return Air.internedToRef((try pt.intern(.{ .ptr = .{
...	@@ -32731,11 +32758,22 @@ fn analyzeNavRefInner(sema: *Sema, src: LazySrcLoc, orig_nav_index: InternPool.N	...	@@ -32731,11 +32758,22 @@ fn analyzeNavRefInner(sema: *Sema, src: LazySrcLoc, orig_nav_index: InternPool.N
32731	}	32758	}
32732		32759
32733	fn maybeQueueFuncBodyAnalysis(sema: *Sema, src: LazySrcLoc, nav_index: InternPool.Nav.Index) !void {	32760	fn maybeQueueFuncBodyAnalysis(sema: *Sema, src: LazySrcLoc, nav_index: InternPool.Nav.Index) !void {
32734	const zcu = sema.pt.zcu;	32761	const pt = sema.pt;
		32762	const zcu = pt.zcu;
32735	const ip = &zcu.intern_pool;	32763	const ip = &zcu.intern_pool;
		32764
		32765	// To avoid forcing too much resolution, let's first resolve the type, and check if it's a function.
		32766	// If it is, we can resolve the value, and queue analysis as needed.
		32767
		32768	try sema.ensureNavResolved(src, nav_index, .type);
		32769	const nav_ty: Type = .fromInterned(ip.getNav(nav_index).typeOf(ip));
		32770	if (nav_ty.zigTypeTag(zcu) != .@"fn") return;
		32771	if (!try nav_ty.fnHasRuntimeBitsSema(pt)) return;
		32772
		32773	try sema.ensureNavResolved(src, nav_index, .fully);
32736	const nav_val = zcu.navValue(nav_index);	32774	const nav_val = zcu.navValue(nav_index);
32737	if (!ip.isFuncBody(nav_val.toIntern())) return;	32775	if (!ip.isFuncBody(nav_val.toIntern())) return;
32738	if (!try nav_val.typeOf(zcu).fnHasRuntimeBitsSema(sema.pt)) return;	32776
32739	try sema.addReferenceEntry(src, AnalUnit.wrap(.{ .func = nav_val.toIntern() }));	32777	try sema.addReferenceEntry(src, AnalUnit.wrap(.{ .func = nav_val.toIntern() }));
32740	try zcu.ensureFuncBodyAnalysisQueued(nav_val.toIntern());	32778	try zcu.ensureFuncBodyAnalysisQueued(nav_val.toIntern());
32741	}	32779	}
...	@@ -38450,11 +38488,16 @@ pub fn declareDependency(sema: *Sema, dependee: InternPool.Dependee) !void {	...	@@ -38450,11 +38488,16 @@ pub fn declareDependency(sema: *Sema, dependee: InternPool.Dependee) !void {
38450	// of a type and they use `@This()`. This dependency would be unnecessary, and in fact would	38488	// of a type and they use `@This()`. This dependency would be unnecessary, and in fact would
38451	// just result in over-analysis since `Zcu.findOutdatedToAnalyze` would never be able to resolve	38489	// just result in over-analysis since `Zcu.findOutdatedToAnalyze` would never be able to resolve
38452	// the loop.	38490	// the loop.
		38491	// Note that this also disallows a `nav_val`
38453	switch (sema.owner.unwrap()) {	38492	switch (sema.owner.unwrap()) {
38454	.nav_val => \|this_nav\| switch (dependee) {	38493	.nav_val => \|this_nav\| switch (dependee) {
38455	.nav_val => \|other_nav\| if (this_nav == other_nav) return,	38494	.nav_val => \|other_nav\| if (this_nav == other_nav) return,
38456	else => {},	38495	else => {},
38457	},	38496	},
		38497	.nav_ty => \|this_nav\| switch (dependee) {
		38498	.nav_ty => \|other_nav\| if (this_nav == other_nav) return,
		38499	else => {},
		38500	},
38458	else => {},	38501	else => {},
38459	}	38502	}
38460		38503
...	@@ -38873,8 +38916,8 @@ fn getBuiltinInnerType(	...	@@ -38873,8 +38916,8 @@ fn getBuiltinInnerType(
38873	const nav = opt_nav orelse return sema.fail(block, src, "std.builtin.{s} missing {s}", .{	38916	const nav = opt_nav orelse return sema.fail(block, src, "std.builtin.{s} missing {s}", .{
38874	compile_error_parent_name, inner_name,	38917	compile_error_parent_name, inner_name,
38875	});	38918	});
38876	try sema.ensureNavResolved(src, nav);	38919	try sema.ensureNavResolved(src, nav, .fully);
38877	const val = Value.fromInterned(ip.getNav(nav).status.resolved.val);	38920	const val = Value.fromInterned(ip.getNav(nav).status.fully_resolved.val);
38878	const ty = val.toType();	38921	const ty = val.toType();
38879	try ty.resolveFully(pt);	38922	try ty.resolveFully(pt);
38880	return ty;	38923	return ty;
...	@@ -38886,5 +38929,73 @@ fn getBuiltin(sema: *Sema, name: []const u8) SemaError!Air.Inst.Ref {	...	@@ -38886,5 +38929,73 @@ fn getBuiltin(sema: *Sema, name: []const u8) SemaError!Air.Inst.Ref {
38886	const ip = &zcu.intern_pool;	38929	const ip = &zcu.intern_pool;
38887	const nav = try pt.getBuiltinNav(name);	38930	const nav = try pt.getBuiltinNav(name);
38888	try pt.ensureNavValUpToDate(nav);	38931	try pt.ensureNavValUpToDate(nav);
38889	return Air.internedToRef(ip.getNav(nav).status.resolved.val);	38932	return Air.internedToRef(ip.getNav(nav).status.fully_resolved.val);
		38933	}
		38934
		38935	pub const NavPtrModifiers = struct {
		38936	alignment: Alignment,
		38937	@"linksection": InternPool.OptionalNullTerminatedString,
		38938	@"addrspace": std.builtin.AddressSpace,
		38939	};
		38940
		38941	pub fn resolveNavPtrModifiers(
		38942	sema: *Sema,
		38943	block: *Block,
		38944	zir_decl: Zir.Inst.Declaration.Unwrapped,
		38945	decl_inst: Zir.Inst.Index,
		38946	nav_ty: Type,
		38947	) CompileError!NavPtrModifiers {
		38948	const pt = sema.pt;
		38949	const zcu = pt.zcu;
		38950	const gpa = zcu.gpa;
		38951	const ip = &zcu.intern_pool;
		38952
		38953	const align_src = block.src(.{ .node_offset_var_decl_align = 0 });
		38954	const section_src = block.src(.{ .node_offset_var_decl_section = 0 });
		38955	const addrspace_src = block.src(.{ .node_offset_var_decl_addrspace = 0 });
		38956
		38957	const alignment: InternPool.Alignment = a: {
		38958	const align_body = zir_decl.align_body orelse break :a .none;
		38959	const align_ref = try sema.resolveInlineBody(block, align_body, decl_inst);
		38960	break :a try sema.analyzeAsAlign(block, align_src, align_ref);
		38961	};
		38962
		38963	const @"linksection": InternPool.OptionalNullTerminatedString = ls: {
		38964	const linksection_body = zir_decl.linksection_body orelse break :ls .none;
		38965	const linksection_ref = try sema.resolveInlineBody(block, linksection_body, decl_inst);
		38966	const bytes = try sema.toConstString(block, section_src, linksection_ref, .{
		38967	.needed_comptime_reason = "linksection must be comptime-known",
		38968	});
		38969	if (std.mem.indexOfScalar(u8, bytes, 0) != null) {
		38970	return sema.fail(block, section_src, "linksection cannot contain null bytes", .{});
		38971	} else if (bytes.len == 0) {
		38972	return sema.fail(block, section_src, "linksection cannot be empty", .{});
		38973	}
		38974	break :ls try ip.getOrPutStringOpt(gpa, pt.tid, bytes, .no_embedded_nulls);
		38975	};
		38976
		38977	const @"addrspace": std.builtin.AddressSpace = as: {
		38978	const addrspace_ctx: Sema.AddressSpaceContext = switch (zir_decl.kind) {
		38979	.@"var" => .variable,
		38980	else => switch (nav_ty.zigTypeTag(zcu)) {
		38981	.@"fn" => .function,
		38982	else => .constant,
		38983	},
		38984	};
		38985	const target = zcu.getTarget();
		38986	const addrspace_body = zir_decl.addrspace_body orelse break :as switch (addrspace_ctx) {
		38987	.function => target_util.defaultAddressSpace(target, .function),
		38988	.variable => target_util.defaultAddressSpace(target, .global_mutable),
		38989	.constant => target_util.defaultAddressSpace(target, .global_constant),
		38990	else => unreachable,
		38991	};
		38992	const addrspace_ref = try sema.resolveInlineBody(block, addrspace_body, decl_inst);
		38993	break :as try sema.analyzeAsAddressSpace(block, addrspace_src, addrspace_ref, addrspace_ctx);
		38994	};
		38995
		38996	return .{
		38997	.alignment = alignment,
		38998	.@"linksection" = @"linksection",
		38999	.@"addrspace" = @"addrspace",
		39000	};
38890	}	39001	}

src/Sema/comptime_ptr_access.zig+2-3

 @@ -219,9 +219,8 @@ fn loadComptimePtrInner(
     const base_val: MutableValue = switch (ptr.base_addr) {
         .nav => |nav| val: {
-            try sema.declareDependency(.{ .nav_val = nav });
+            try sema.ensureNavResolved(src, nav, .fully);
-            try sema.ensureNavResolved(src, nav);
+            const val = ip.getNav(nav).status.fully_resolved.val;
-            const val = ip.getNav(nav).status.resolved.val;
             switch (ip.indexToKey(val)) {
                 .variable => return .runtime_load,
                 // We let `.@"extern"` through here if it's a function.

src/Value.zig+6-1

 @@ -1343,7 +1343,12 @@ pub fn isLazySize(val: Value, zcu: *Zcu) bool {
 pub fn isPtrRuntimeValue(val: Value, zcu: *Zcu) bool {
     const ip = &zcu.intern_pool;
     const nav = ip.getBackingNav(val.toIntern()).unwrap() orelse return false;
-    return switch (ip.indexToKey(ip.getNav(nav).status.resolved.val)) {
+    const nav_val = switch (ip.getNav(nav).status) {
+        .unresolved => unreachable,
+        .type_resolved => |r| return r.is_threadlocal,
+        .fully_resolved => |r| r.val,
+    };
+    return switch (ip.indexToKey(nav_val)) {
         .@"extern" => |e| e.is_threadlocal or e.is_dll_import,
         .variable => |v| v.is_threadlocal,
         else => false,

src/Zcu.zig+72-9

...	@@ -170,6 +170,9 @@ outdated_ready: std.AutoArrayHashMapUnmanaged(AnalUnit, void) = .empty,	...	@@ -170,6 +170,9 @@ outdated_ready: std.AutoArrayHashMapUnmanaged(AnalUnit, void) = .empty,
170	/// it as outdated.	170	/// it as outdated.
171	retryable_failures: std.ArrayListUnmanaged(AnalUnit) = .empty,	171	retryable_failures: std.ArrayListUnmanaged(AnalUnit) = .empty,
172		172
		173	func_body_analysis_queued: std.AutoArrayHashMapUnmanaged(InternPool.Index, void) = .empty,
		174	nav_val_analysis_queued: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void) = .empty,
		175
173	/// These are the modules which we initially queue for analysis in `Compilation.update`.	176	/// These are the modules which we initially queue for analysis in `Compilation.update`.
174	/// `resolveReferences` will use these as the root of its reachability traversal.	177	/// `resolveReferences` will use these as the root of its reachability traversal.
175	analysis_roots: std.BoundedArray(*Package.Module, 3) = .{},	178	analysis_roots: std.BoundedArray(*Package.Module, 3) = .{},
...	@@ -282,7 +285,11 @@ pub const Exported = union(enum) {	...	@@ -282,7 +285,11 @@ pub const Exported = union(enum) {
282		285
283	pub fn getAlign(exported: Exported, zcu: *Zcu) Alignment {	286	pub fn getAlign(exported: Exported, zcu: *Zcu) Alignment {
284	return switch (exported) {	287	return switch (exported) {
285	.nav => \|nav\| zcu.intern_pool.getNav(nav).status.resolved.alignment,	288	.nav => \|nav\| switch (zcu.intern_pool.getNav(nav).status) {
		289	.unresolved => unreachable,
		290	.type_resolved => \|r\| r.alignment,
		291	.fully_resolved => \|r\| r.alignment,
		292	},
286	.uav => .none,	293	.uav => .none,
287	};	294	};
288	}	295	}
...	@@ -2241,6 +2248,9 @@ pub fn deinit(zcu: *Zcu) void {	...	@@ -2241,6 +2248,9 @@ pub fn deinit(zcu: *Zcu) void {
2241	zcu.outdated_ready.deinit(gpa);	2248	zcu.outdated_ready.deinit(gpa);
2242	zcu.retryable_failures.deinit(gpa);	2249	zcu.retryable_failures.deinit(gpa);
2243		2250
		2251	zcu.func_body_analysis_queued.deinit(gpa);
		2252	zcu.nav_val_analysis_queued.deinit(gpa);
		2253
2244	zcu.test_functions.deinit(gpa);	2254	zcu.test_functions.deinit(gpa);
2245		2255
2246	for (zcu.global_assembly.values()) \|s\| {	2256	for (zcu.global_assembly.values()) \|s\| {
...	@@ -2441,6 +2451,7 @@ pub fn markPoDependeeUpToDate(zcu: *Zcu, dependee: InternPool.Dependee) !void {	...	@@ -2441,6 +2451,7 @@ pub fn markPoDependeeUpToDate(zcu: *Zcu, dependee: InternPool.Dependee) !void {
2441	switch (depender.unwrap()) {	2451	switch (depender.unwrap()) {
2442	.@"comptime" => {},	2452	.@"comptime" => {},
2443	.nav_val => \|nav\| try zcu.markPoDependeeUpToDate(.{ .nav_val = nav }),	2453	.nav_val => \|nav\| try zcu.markPoDependeeUpToDate(.{ .nav_val = nav }),
		2454	.nav_ty => \|nav\| try zcu.markPoDependeeUpToDate(.{ .nav_ty = nav }),
2444	.type => \|ty\| try zcu.markPoDependeeUpToDate(.{ .interned = ty }),	2455	.type => \|ty\| try zcu.markPoDependeeUpToDate(.{ .interned = ty }),
2445	.func => \|func\| try zcu.markPoDependeeUpToDate(.{ .interned = func }),	2456	.func => \|func\| try zcu.markPoDependeeUpToDate(.{ .interned = func }),
2446	}	2457	}
...	@@ -2453,7 +2464,8 @@ fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: AnalUni	...	@@ -2453,7 +2464,8 @@ fn markTransitiveDependersPotentiallyOutdated(zcu: *Zcu, maybe_outdated: AnalUni
2453	const ip = &zcu.intern_pool;	2464	const ip = &zcu.intern_pool;
2454	const dependee: InternPool.Dependee = switch (maybe_outdated.unwrap()) {	2465	const dependee: InternPool.Dependee = switch (maybe_outdated.unwrap()) {
2455	.@"comptime" => return, // analysis of a comptime decl can't outdate any dependencies	2466	.@"comptime" => return, // analysis of a comptime decl can't outdate any dependencies
2456	.nav_val => \|nav\| .{ .nav_val = nav }, // TODO: also `nav_ref` deps when introduced	2467	.nav_val => \|nav\| .{ .nav_val = nav },
		2468	.nav_ty => \|nav\| .{ .nav_ty = nav },
2457	.type => \|ty\| .{ .interned = ty },	2469	.type => \|ty\| .{ .interned = ty },
2458	.func => \|func_index\| .{ .interned = func_index }, // IES	2470	.func => \|func_index\| .{ .interned = func_index }, // IES
2459	};	2471	};
...	@@ -2540,6 +2552,7 @@ pub fn findOutdatedToAnalyze(zcu: *Zcu) Allocator.Error!?AnalUnit {	...	@@ -2540,6 +2552,7 @@ pub fn findOutdatedToAnalyze(zcu: *Zcu) Allocator.Error!?AnalUnit {
2540	.@"comptime" => continue, // a `comptime` block can't even be depended on so it is a terrible choice	2552	.@"comptime" => continue, // a `comptime` block can't even be depended on so it is a terrible choice
2541	.type => \|ty\| .{ .interned = ty },	2553	.type => \|ty\| .{ .interned = ty },
2542	.nav_val => \|nav\| .{ .nav_val = nav },	2554	.nav_val => \|nav\| .{ .nav_val = nav },
		2555	.nav_ty => \|nav\| .{ .nav_ty = nav },
2543	});	2556	});
2544	while (it.next()) \|_\| n += 1;	2557	while (it.next()) \|_\| n += 1;
2545		2558
...	@@ -2780,14 +2793,39 @@ pub fn ensureFuncBodyAnalysisQueued(zcu: *Zcu, func_index: InternPool.Index) !vo	...	@@ -2780,14 +2793,39 @@ pub fn ensureFuncBodyAnalysisQueued(zcu: *Zcu, func_index: InternPool.Index) !vo
2780	const ip = &zcu.intern_pool;	2793	const ip = &zcu.intern_pool;
2781	const func = zcu.funcInfo(func_index);	2794	const func = zcu.funcInfo(func_index);
2782		2795
2783	switch (func.analysisUnordered(ip).state) {	2796	if (zcu.func_body_analysis_queued.contains(func_index)) return;
2784	.unreferenced => {}, // We're the first reference!	2797
2785	.queued => return, // Analysis is already queued.	2798	if (func.analysisUnordered(ip).is_analyzed) {
2786	.analyzed => return, // Analysis is complete; if it's out-of-date, it'll be re-analyzed later this update.	2799	if (!zcu.outdated.contains(.wrap(.{ .func = func_index })) and
		2800	!zcu.potentially_outdated.contains(.wrap(.{ .func = func_index })))
		2801	{
		2802	// This function has been analyzed before and is definitely up-to-date.
		2803	return;
		2804	}
2787	}	2805	}
2788		2806
		2807	try zcu.func_body_analysis_queued.ensureUnusedCapacity(zcu.gpa, 1);
2789	try zcu.comp.queueJob(.{ .analyze_func = func_index });	2808	try zcu.comp.queueJob(.{ .analyze_func = func_index });
2790	func.setAnalysisState(ip, .queued);	2809	zcu.func_body_analysis_queued.putAssumeCapacityNoClobber(func_index, {});
		2810	}
		2811
		2812	pub fn ensureNavValAnalysisQueued(zcu: *Zcu, nav_id: InternPool.Nav.Index) !void {
		2813	const ip = &zcu.intern_pool;
		2814
		2815	if (zcu.nav_val_analysis_queued.contains(nav_id)) return;
		2816
		2817	if (ip.getNav(nav_id).status == .fully_resolved) {
		2818	if (!zcu.outdated.contains(.wrap(.{ .nav_val = nav_id })) and
		2819	!zcu.potentially_outdated.contains(.wrap(.{ .nav_val = nav_id })))
		2820	{
		2821	// This `Nav` has been analyzed before and is definitely up-to-date.
		2822	return;
		2823	}
		2824	}
		2825
		2826	try zcu.nav_val_analysis_queued.ensureUnusedCapacity(zcu.gpa, 1);
		2827	try zcu.comp.queueJob(.{ .analyze_comptime_unit = .wrap(.{ .nav_val = nav_id }) });
		2828	zcu.nav_val_analysis_queued.putAssumeCapacityNoClobber(nav_id, {});
2791	}	2829	}
2792		2830
2793	pub const ImportFileResult = struct {	2831	pub const ImportFileResult = struct {
...	@@ -3424,6 +3462,17 @@ fn resolveReferencesInner(zcu: *Zcu) !std.AutoHashMapUnmanaged(AnalUnit, ?Resolv	...	@@ -3424,6 +3462,17 @@ fn resolveReferencesInner(zcu: *Zcu) !std.AutoHashMapUnmanaged(AnalUnit, ?Resolv
3424	const unit = kv.key;	3462	const unit = kv.key;
3425	try result.putNoClobber(gpa, unit, kv.value);	3463	try result.putNoClobber(gpa, unit, kv.value);
3426		3464
		3465	// `nav_val` and `nav_ty` reference each other implicitly to save memory.
		3466	queue_paired: {
		3467	const other: AnalUnit = .wrap(switch (unit.unwrap()) {
		3468	.nav_val => \|n\| .{ .nav_ty = n },
		3469	.nav_ty => \|n\| .{ .nav_val = n },
		3470	.@"comptime", .type, .func => break :queue_paired,
		3471	});
		3472	if (result.contains(other)) break :queue_paired;
		3473	try unit_queue.put(gpa, other, kv.value); // same reference location
		3474	}
		3475
3427	log.debug("handle unit '{}'", .{zcu.fmtAnalUnit(unit)});	3476	log.debug("handle unit '{}'", .{zcu.fmtAnalUnit(unit)});
3428		3477
3429	if (zcu.reference_table.get(unit)) \|first_ref_idx\| {	3478	if (zcu.reference_table.get(unit)) \|first_ref_idx\| {
...	@@ -3513,7 +3562,7 @@ pub fn navSrcLine(zcu: *Zcu, nav_index: InternPool.Nav.Index) u32 {	...	@@ -3513,7 +3562,7 @@ pub fn navSrcLine(zcu: *Zcu, nav_index: InternPool.Nav.Index) u32 {
3513	}	3562	}
3514		3563
3515	pub fn navValue(zcu: *const Zcu, nav_index: InternPool.Nav.Index) Value {	3564	pub fn navValue(zcu: *const Zcu, nav_index: InternPool.Nav.Index) Value {
3516	return Value.fromInterned(zcu.intern_pool.getNav(nav_index).status.resolved.val);	3565	return Value.fromInterned(zcu.intern_pool.getNav(nav_index).status.fully_resolved.val);
3517	}	3566	}
3518		3567
3519	pub fn navFileScopeIndex(zcu: *Zcu, nav: InternPool.Nav.Index) File.Index {	3568	pub fn navFileScopeIndex(zcu: *Zcu, nav: InternPool.Nav.Index) File.Index {
...	@@ -3547,6 +3596,7 @@ fn formatAnalUnit(data: struct { unit: AnalUnit, zcu: *Zcu }, comptime fmt: []co	...	@@ -3547,6 +3596,7 @@ fn formatAnalUnit(data: struct { unit: AnalUnit, zcu: *Zcu }, comptime fmt: []co
3547	}	3596	}
3548	},	3597	},
3549	.nav_val => \|nav\| return writer.print("nav_val('{}')", .{ip.getNav(nav).fqn.fmt(ip)}),	3598	.nav_val => \|nav\| return writer.print("nav_val('{}')", .{ip.getNav(nav).fqn.fmt(ip)}),
		3599	.nav_ty => \|nav\| return writer.print("nav_ty('{}')", .{ip.getNav(nav).fqn.fmt(ip)}),
3550	.type => \|ty\| return writer.print("ty('{}')", .{Type.fromInterned(ty).containerTypeName(ip).fmt(ip)}),	3600	.type => \|ty\| return writer.print("ty('{}')", .{Type.fromInterned(ty).containerTypeName(ip).fmt(ip)}),
3551	.func => \|func\| {	3601	.func => \|func\| {
3552	const nav = zcu.funcInfo(func).owner_nav;	3602	const nav = zcu.funcInfo(func).owner_nav;
...	@@ -3572,7 +3622,11 @@ fn formatDependee(data: struct { dependee: InternPool.Dependee, zcu: *Zcu }, com	...	@@ -3572,7 +3622,11 @@ fn formatDependee(data: struct { dependee: InternPool.Dependee, zcu: *Zcu }, com
3572	},	3622	},
3573	.nav_val => \|nav\| {	3623	.nav_val => \|nav\| {
3574	const fqn = ip.getNav(nav).fqn;	3624	const fqn = ip.getNav(nav).fqn;
3575	return writer.print("nav('{}')", .{fqn.fmt(ip)});	3625	return writer.print("nav_val('{}')", .{fqn.fmt(ip)});
		3626	},
		3627	.nav_ty => \|nav\| {
		3628	const fqn = ip.getNav(nav).fqn;
		3629	return writer.print("nav_ty('{}')", .{fqn.fmt(ip)});
3576	},	3630	},
3577	.interned => \|ip_index\| switch (ip.indexToKey(ip_index)) {	3631	.interned => \|ip_index\| switch (ip.indexToKey(ip_index)) {
3578	.struct_type, .union_type, .enum_type => return writer.print("type('{}')", .{Type.fromInterned(ip_index).containerTypeName(ip).fmt(ip)}),	3632	.struct_type, .union_type, .enum_type => return writer.print("type('{}')", .{Type.fromInterned(ip_index).containerTypeName(ip).fmt(ip)}),
...	@@ -3749,3 +3803,12 @@ pub fn callconvSupported(zcu: *Zcu, cc: std.builtin.CallingConvention) union(enu	...	@@ -3749,3 +3803,12 @@ pub fn callconvSupported(zcu: *Zcu, cc: std.builtin.CallingConvention) union(enu
3749	if (!backend_ok) return .{ .bad_backend = backend };	3803	if (!backend_ok) return .{ .bad_backend = backend };
3750	return .ok;	3804	return .ok;
3751	}	3805	}
		3806
		3807	/// Given that a `Nav` has value `val`, determine if a ref of that `Nav` gives a `const` pointer.
		3808	pub fn navValIsConst(zcu: *const Zcu, val: InternPool.Index) bool {
		3809	return switch (zcu.intern_pool.indexToKey(val)) {
		3810	.variable => false,
		3811	.@"extern" => \|e\| e.is_const,
		3812	else => true,
		3813	};
		3814	}

src/Zcu/PerThread.zig+340-136

...	@@ -731,10 +731,12 @@ pub fn ensureNavValUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu	...	@@ -731,10 +731,12 @@ pub fn ensureNavValUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu
731	const gpa = zcu.gpa;	731	const gpa = zcu.gpa;
732	const ip = &zcu.intern_pool;	732	const ip = &zcu.intern_pool;
733		733
		734	_ = zcu.nav_val_analysis_queued.swapRemove(nav_id);
		735
734	const anal_unit: AnalUnit = .wrap(.{ .nav_val = nav_id });	736	const anal_unit: AnalUnit = .wrap(.{ .nav_val = nav_id });
735	const nav = ip.getNav(nav_id);	737	const nav = ip.getNav(nav_id);
736		738
737	log.debug("ensureNavUpToDate {}", .{zcu.fmtAnalUnit(anal_unit)});	739	log.debug("ensureNavValUpToDate {}", .{zcu.fmtAnalUnit(anal_unit)});
738		740
739	// Determine whether or not this `Nav`'s value is outdated. This also includes checking if the	741	// Determine whether or not this `Nav`'s value is outdated. This also includes checking if the
740	// status is `.unresolved`, which indicates that the value is outdated because it has never	742	// status is `.unresolved`, which indicates that the value is outdated because it has never
...	@@ -763,19 +765,19 @@ pub fn ensureNavValUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu	...	@@ -763,19 +765,19 @@ pub fn ensureNavValUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu
763	} else {	765	} else {
764	// We can trust the current information about this unit.	766	// We can trust the current information about this unit.
765	if (prev_failed) return error.AnalysisFail;	767	if (prev_failed) return error.AnalysisFail;
766	if (nav.status == .resolved) return;	768	switch (nav.status) {
		769	.unresolved, .type_resolved => {},
		770	.fully_resolved => return,
		771	}
767	}	772	}
768		773
769	const unit_prog_node = zcu.sema_prog_node.start(nav.fqn.toSlice(ip), 0);	774	const unit_prog_node = zcu.sema_prog_node.start(nav.fqn.toSlice(ip), 0);
770	defer unit_prog_node.end();	775	defer unit_prog_node.end();
771		776
772	const sema_result: SemaNavResult, const new_failed: bool = if (pt.analyzeNavVal(nav_id)) \|result\| res: {	777	const invalidate_value: bool, const new_failed: bool = if (pt.analyzeNavVal(nav_id)) \|result\| res: {
773	break :res .{	778	break :res .{
774	.{	779	// If the unit has gone from failed to success, we still need to invalidate the dependencies.
775	// If the unit has gone from failed to success, we still need to invalidate the dependencies.	780	result.val_changed or prev_failed,
776	.invalidate_nav_val = result.invalidate_nav_val or prev_failed,
777	.invalidate_nav_ref = result.invalidate_nav_ref or prev_failed,
778	},
779	false,	781	false,
780	};	782	};
781	} else \|err\| switch (err) {	783	} else \|err\| switch (err) {
...	@@ -786,10 +788,7 @@ pub fn ensureNavValUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu	...	@@ -786,10 +788,7 @@ pub fn ensureNavValUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu
786	try zcu.transitive_failed_analysis.put(gpa, anal_unit, {});	788	try zcu.transitive_failed_analysis.put(gpa, anal_unit, {});
787	log.debug("mark transitive analysis failure for {}", .{zcu.fmtAnalUnit(anal_unit)});	789	log.debug("mark transitive analysis failure for {}", .{zcu.fmtAnalUnit(anal_unit)});
788	}	790	}
789	break :res .{ .{	791	break :res .{ !prev_failed, true };
790	.invalidate_nav_val = !prev_failed,
791	.invalidate_nav_ref = !prev_failed,
792	}, true };
793	},	792	},
794	error.OutOfMemory => {	793	error.OutOfMemory => {
795	// TODO: it's unclear how to gracefully handle this.	794	// TODO: it's unclear how to gracefully handle this.
...	@@ -806,10 +805,8 @@ pub fn ensureNavValUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu	...	@@ -806,10 +805,8 @@ pub fn ensureNavValUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu
806	};	805	};
807		806
808	if (was_outdated) {	807	if (was_outdated) {
809	// TODO: we do not yet have separate dependencies for Nav values vs types.
810	const invalidate = sema_result.invalidate_nav_val or sema_result.invalidate_nav_ref;
811	const dependee: InternPool.Dependee = .{ .nav_val = nav_id };	808	const dependee: InternPool.Dependee = .{ .nav_val = nav_id };
812	if (invalidate) {	809	if (invalidate_value) {
813	// This dependency was marked as PO, meaning dependees were waiting	810	// This dependency was marked as PO, meaning dependees were waiting
814	// on its analysis result, and it has turned out to be outdated.	811	// on its analysis result, and it has turned out to be outdated.
815	// Update dependees accordingly.	812	// Update dependees accordingly.
...	@@ -824,14 +821,7 @@ pub fn ensureNavValUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu	...	@@ -824,14 +821,7 @@ pub fn ensureNavValUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu
824	if (new_failed) return error.AnalysisFail;	821	if (new_failed) return error.AnalysisFail;
825	}	822	}
826		823
827	const SemaNavResult = packed struct {	824	fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileError!struct { val_changed: bool } {
828	/// Whether the value of a `decl_val` of the corresponding Nav changed.
829	invalidate_nav_val: bool,
830	/// Whether the type of a `decl_ref` of the corresponding Nav changed.
831	invalidate_nav_ref: bool,
832	};
833
834	fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileError!SemaNavResult {
835	const zcu = pt.zcu;	825	const zcu = pt.zcu;
836	const gpa = zcu.gpa;	826	const gpa = zcu.gpa;
837	const ip = &zcu.intern_pool;	827	const ip = &zcu.intern_pool;
...	@@ -875,9 +865,13 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr	...	@@ -875,9 +865,13 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
875	};	865	};
876	defer sema.deinit();	866	defer sema.deinit();
877		867
878	// The comptime unit declares on the source of the corresponding declaration.	868	// Every `Nav` declares a dependency on the source of the corresponding declaration.
879	try sema.declareDependency(.{ .src_hash = old_nav.analysis.?.zir_index });	869	try sema.declareDependency(.{ .src_hash = old_nav.analysis.?.zir_index });
880		870
		871	// In theory, we would also add a reference to the corresponding `nav_val` unit here: there are
		872	// always references in both directions between a `nav_val` and `nav_ty`. However, to save memory,
		873	// these references are known implicitly. See logic in `Zcu.resolveReferences`.
		874
881	var block: Sema.Block = .{	875	var block: Sema.Block = .{
882	.parent = null,	876	.parent = null,
883	.sema = &sema,	877	.sema = &sema,
...	@@ -891,31 +885,44 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr	...	@@ -891,31 +885,44 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
891	defer block.instructions.deinit(gpa);	885	defer block.instructions.deinit(gpa);
892		886
893	const zir_decl = zir.getDeclaration(inst_resolved.inst);	887	const zir_decl = zir.getDeclaration(inst_resolved.inst);
894
895	assert(old_nav.is_usingnamespace == (zir_decl.kind == .@"usingnamespace"));	888	assert(old_nav.is_usingnamespace == (zir_decl.kind == .@"usingnamespace"));
896		889
		890	const ty_src = block.src(.{ .node_offset_var_decl_ty = 0 });
		891	const init_src = block.src(.{ .node_offset_var_decl_init = 0 });
897	const align_src = block.src(.{ .node_offset_var_decl_align = 0 });	892	const align_src = block.src(.{ .node_offset_var_decl_align = 0 });
898	const section_src = block.src(.{ .node_offset_var_decl_section = 0 });	893	const section_src = block.src(.{ .node_offset_var_decl_section = 0 });
899	const addrspace_src = block.src(.{ .node_offset_var_decl_addrspace = 0 });	894	const addrspace_src = block.src(.{ .node_offset_var_decl_addrspace = 0 });
900	const ty_src = block.src(.{ .node_offset_var_decl_ty = 0 });	895
901	const init_src = block.src(.{ .node_offset_var_decl_init = 0 });	896	const maybe_ty: ?Type = if (zir_decl.type_body != null) ty: {
		897	// Since we have a type body, the type is resolved separately!
		898	// Of course, we need to make sure we depend on it properly.
		899	try sema.declareDependency(.{ .nav_ty = nav_id });
		900	try pt.ensureNavTypeUpToDate(nav_id);
		901	break :ty .fromInterned(ip.getNav(nav_id).status.type_resolved.type);
		902	} else null;
		903
		904	const final_val: ?Value = if (zir_decl.value_body) \|value_body\| val: {
		905	if (maybe_ty) \|ty\| {
		906	// Put the resolved type into `inst_map` to be used as the result type of the init.
		907	try sema.inst_map.ensureSpaceForInstructions(gpa, &.{inst_resolved.inst});
		908	sema.inst_map.putAssumeCapacity(inst_resolved.inst, Air.internedToRef(ty.toIntern()));
		909	const uncoerced_result_ref = try sema.resolveInlineBody(&block, value_body, inst_resolved.inst);
		910	assert(sema.inst_map.remove(inst_resolved.inst));
		911
		912	const result_ref = try sema.coerce(&block, ty, uncoerced_result_ref, init_src);
		913	break :val try sema.resolveFinalDeclValue(&block, init_src, result_ref);
		914	} else {
		915	// Just analyze the value; we have no type to offer.
		916	const result_ref = try sema.resolveInlineBody(&block, value_body, inst_resolved.inst);
		917	break :val try sema.resolveFinalDeclValue(&block, init_src, result_ref);
		918	}
		919	} else null;
		920
		921	const nav_ty: Type = maybe_ty orelse final_val.?.typeOf(zcu);
902		922
903	// First, we must resolve the declaration's type. To do this, we analyze the type body if available,	923	// First, we must resolve the declaration's type. To do this, we analyze the type body if available,
904	// or otherwise, we analyze the value body, populating `early_val` in the process.	924	// or otherwise, we analyze the value body, populating `early_val` in the process.
905		925
906	const nav_ty: Type, const early_val: ?Value = if (zir_decl.type_body) \|type_body\| ty: {
907	// We evaluate only the type now; no need for the value yet.
908	const uncoerced_type_ref = try sema.resolveInlineBody(&block, type_body, inst_resolved.inst);
909	const type_ref = try sema.coerce(&block, .type, uncoerced_type_ref, ty_src);
910	break :ty .{ .fromInterned(type_ref.toInterned().?), null };
911	} else ty: {
912	// We don't have a type body, so we need to evaluate the value immediately.
913	const value_body = zir_decl.value_body.?;
914	const result_ref = try sema.resolveInlineBody(&block, value_body, inst_resolved.inst);
915	const val = try sema.resolveFinalDeclValue(&block, init_src, result_ref);
916	break :ty .{ val.typeOf(zcu), val };
917	};
918
919	switch (zir_decl.kind) {	926	switch (zir_decl.kind) {
920	.@"comptime" => unreachable, // this is not a Nav	927	.@"comptime" => unreachable, // this is not a Nav
921	.unnamed_test, .@"test", .decltest => assert(nav_ty.zigTypeTag(zcu) == .@"fn"),	928	.unnamed_test, .@"test", .decltest => assert(nav_ty.zigTypeTag(zcu) == .@"fn"),
...	@@ -932,58 +939,24 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr	...	@@ -932,58 +939,24 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
932	// Now that we know the type, we can evaluate the alignment, linksection, and addrspace, to determine	939	// Now that we know the type, we can evaluate the alignment, linksection, and addrspace, to determine
933	// the full pointer type of this declaration.	940	// the full pointer type of this declaration.
934		941
935	const alignment: InternPool.Alignment = a: {	942	const modifiers: Sema.NavPtrModifiers = if (zir_decl.type_body != null) m: {
936	const align_body = zir_decl.align_body orelse break :a .none;	943	// `analyzeNavType` (from the `ensureNavTypeUpToDate` call above) has already populated this data into
937	const align_ref = try sema.resolveInlineBody(&block, align_body, inst_resolved.inst);	944	// the `Nav`. Load the new one, and pull the modifiers out.
938	break :a try sema.analyzeAsAlign(&block, align_src, align_ref);	945	switch (ip.getNav(nav_id).status) {
939	};	946	.unresolved => unreachable, // `analyzeNavType` will never leave us in this state
940		947	inline .type_resolved, .fully_resolved => \|r\| break :m .{
941	const @"linksection": InternPool.OptionalNullTerminatedString = ls: {	948	.alignment = r.alignment,
942	const linksection_body = zir_decl.linksection_body orelse break :ls .none;	949	.@"linksection" = r.@"linksection",
943	const linksection_ref = try sema.resolveInlineBody(&block, linksection_body, inst_resolved.inst);	950	.@"addrspace" = r.@"addrspace",
944	const bytes = try sema.toConstString(&block, section_src, linksection_ref, .{
945	.needed_comptime_reason = "linksection must be comptime-known",
946	});
947	if (std.mem.indexOfScalar(u8, bytes, 0) != null) {
948	return sema.fail(&block, section_src, "linksection cannot contain null bytes", .{});
949	} else if (bytes.len == 0) {
950	return sema.fail(&block, section_src, "linksection cannot be empty", .{});
951	}
952	break :ls try ip.getOrPutStringOpt(gpa, pt.tid, bytes, .no_embedded_nulls);
953	};
954
955	const @"addrspace": std.builtin.AddressSpace = as: {
956	const addrspace_ctx: Sema.AddressSpaceContext = switch (zir_decl.kind) {
957	.@"var" => .variable,
958	else => switch (nav_ty.zigTypeTag(zcu)) {
959	.@"fn" => .function,
960	else => .constant,
961	},	951	},
962	};	952	}
963	const target = zcu.getTarget();	953	} else m: {
964	const addrspace_body = zir_decl.addrspace_body orelse break :as switch (addrspace_ctx) {	954	// `analyzeNavType` is essentially a stub which calls us. We are responsible for resolving this data.
965	.function => target_util.defaultAddressSpace(target, .function),	955	break :m try sema.resolveNavPtrModifiers(&block, zir_decl, inst_resolved.inst, nav_ty);
966	.variable => target_util.defaultAddressSpace(target, .global_mutable),
967	.constant => target_util.defaultAddressSpace(target, .global_constant),
968	else => unreachable,
969	};
970	const addrspace_ref = try sema.resolveInlineBody(&block, addrspace_body, inst_resolved.inst);
971	break :as try sema.analyzeAsAddressSpace(&block, addrspace_src, addrspace_ref, addrspace_ctx);
972	};	956	};
973		957
974	// Lastly, we must evaluate the value if we have not already done so. Note, however, that extern declarations	958	// Lastly, we must figure out the actual interned value to store to the `Nav`.
975	// don't have an associated value body.	959	// This isn't necessarily the same as `final_val`!
976
977	const final_val: ?Value = early_val orelse if (zir_decl.value_body) \|value_body\| val: {
978	// Put the resolved type into `inst_map` to be used as the result type of the init.
979	try sema.inst_map.ensureSpaceForInstructions(gpa, &.{inst_resolved.inst});
980	sema.inst_map.putAssumeCapacity(inst_resolved.inst, Air.internedToRef(nav_ty.toIntern()));
981	const uncoerced_result_ref = try sema.resolveInlineBody(&block, value_body, inst_resolved.inst);
982	assert(sema.inst_map.remove(inst_resolved.inst));
983
984	const result_ref = try sema.coerce(&block, nav_ty, uncoerced_result_ref, init_src);
985	break :val try sema.resolveFinalDeclValue(&block, init_src, result_ref);
986	} else null;
987		960
988	const nav_val: Value = switch (zir_decl.linkage) {	961	const nav_val: Value = switch (zir_decl.linkage) {
989	.normal, .@"export" => switch (zir_decl.kind) {	962	.normal, .@"export" => switch (zir_decl.kind) {
...	@@ -1013,8 +986,8 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr	...	@@ -1013,8 +986,8 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
1013	.is_threadlocal = zir_decl.is_threadlocal,	986	.is_threadlocal = zir_decl.is_threadlocal,
1014	.is_weak_linkage = false,	987	.is_weak_linkage = false,
1015	.is_dll_import = false,	988	.is_dll_import = false,
1016	.alignment = alignment,	989	.alignment = modifiers.alignment,
1017	.@"addrspace" = @"addrspace",	990	.@"addrspace" = modifiers.@"addrspace",
1018	.zir_index = old_nav.analysis.?.zir_index, // `declaration` instruction	991	.zir_index = old_nav.analysis.?.zir_index, // `declaration` instruction
1019	.owner_nav = undefined, // ignored by `getExtern`	992	.owner_nav = undefined, // ignored by `getExtern`
1020	}));	993	}));
...	@@ -1047,10 +1020,7 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr	...	@@ -1047,10 +1020,7 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
1047	});	1020	});
1048	// TODO: usingnamespace cannot participate in incremental compilation	1021	// TODO: usingnamespace cannot participate in incremental compilation
1049	assert(zcu.analysis_in_progress.swapRemove(anal_unit));	1022	assert(zcu.analysis_in_progress.swapRemove(anal_unit));
1050	return .{	1023	return .{ .val_changed = true };
1051	.invalidate_nav_val = true,
1052	.invalidate_nav_ref = true,
1053	};
1054	}	1024	}
1055		1025
1056	const queue_linker_work, const is_owned_fn = switch (ip.indexToKey(nav_val.toIntern())) {	1026	const queue_linker_work, const is_owned_fn = switch (ip.indexToKey(nav_val.toIntern())) {
...	@@ -1087,14 +1057,22 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr	...	@@ -1087,14 +1057,22 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
1087		1057
1088	ip.resolveNavValue(nav_id, .{	1058	ip.resolveNavValue(nav_id, .{
1089	.val = nav_val.toIntern(),	1059	.val = nav_val.toIntern(),
1090	.alignment = alignment,	1060	.alignment = modifiers.alignment,
1091	.@"linksection" = @"linksection",	1061	.@"linksection" = modifiers.@"linksection",
1092	.@"addrspace" = @"addrspace",	1062	.@"addrspace" = modifiers.@"addrspace",
1093	});	1063	});
1094		1064
1095	// Mark the unit as completed before evaluating the export!	1065	// Mark the unit as completed before evaluating the export!
1096	assert(zcu.analysis_in_progress.swapRemove(anal_unit));	1066	assert(zcu.analysis_in_progress.swapRemove(anal_unit));
1097		1067
		1068	if (zir_decl.type_body == null) {
		1069	// In this situation, it's possible that we were triggered by `analyzeNavType` up the stack. In that
		1070	// case, we must also signal that the type is now populated to make this export behave correctly.
		1071	// An alternative strategy would be to just put something on the job queue to perform the export, but
		1072	// this is a little more straightforward, if perhaps less elegant.
		1073	_ = zcu.analysis_in_progress.swapRemove(.wrap(.{ .nav_ty = nav_id }));
		1074	}
		1075
1098	if (zir_decl.linkage == .@"export") {	1076	if (zir_decl.linkage == .@"export") {
1099	const export_src = block.src(.{ .token_offset = @intFromBool(zir_decl.is_pub) });	1077	const export_src = block.src(.{ .token_offset = @intFromBool(zir_decl.is_pub) });
1100	const name_slice = zir.nullTerminatedString(zir_decl.name);	1078	const name_slice = zir.nullTerminatedString(zir_decl.name);
...	@@ -1117,21 +1095,246 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr	...	@@ -1117,21 +1095,246 @@ fn analyzeNavVal(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileErr
1117	}	1095	}
1118		1096
1119	switch (old_nav.status) {	1097	switch (old_nav.status) {
1120	.unresolved => return .{	1098	.unresolved, .type_resolved => return .{ .val_changed = true },
1121	.invalidate_nav_val = true,	1099	.fully_resolved => \|old\| return .{ .val_changed = old.val != nav_val.toIntern() },
1122	.invalidate_nav_ref = true,	1100	}
		1101	}
		1102
		1103	pub fn ensureNavTypeUpToDate(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.SemaError!void {
		1104	const tracy = trace(@src());
		1105	defer tracy.end();
		1106
		1107	const zcu = pt.zcu;
		1108	const gpa = zcu.gpa;
		1109	const ip = &zcu.intern_pool;
		1110
		1111	const anal_unit: AnalUnit = .wrap(.{ .nav_ty = nav_id });
		1112	const nav = ip.getNav(nav_id);
		1113
		1114	log.debug("ensureNavTypeUpToDate {}", .{zcu.fmtAnalUnit(anal_unit)});
		1115
		1116	// Determine whether or not this `Nav`'s type is outdated. This also includes checking if the
		1117	// status is `.unresolved`, which indicates that the value is outdated because it has never
		1118	// been analyzed so far.
		1119	//
		1120	// Note that if the unit is PO, we pessimistically assume that it does require re-analysis, to
		1121	// ensure that the unit is definitely up-to-date when this function returns. This mechanism could
		1122	// result in over-analysis if analysis occurs in a poor order; we do our best to avoid this by
		1123	// carefully choosing which units to re-analyze. See `Zcu.findOutdatedToAnalyze`.
		1124
		1125	const was_outdated = zcu.outdated.swapRemove(anal_unit) or
		1126	zcu.potentially_outdated.swapRemove(anal_unit);
		1127
		1128	const prev_failed = zcu.failed_analysis.contains(anal_unit) or
		1129	zcu.transitive_failed_analysis.contains(anal_unit);
		1130
		1131	if (was_outdated) {
		1132	dev.check(.incremental);
		1133	_ = zcu.outdated_ready.swapRemove(anal_unit);
		1134	zcu.deleteUnitExports(anal_unit);
		1135	zcu.deleteUnitReferences(anal_unit);
		1136	if (zcu.failed_analysis.fetchSwapRemove(anal_unit)) \|kv\| {
		1137	kv.value.destroy(gpa);
		1138	}
		1139	_ = zcu.transitive_failed_analysis.swapRemove(anal_unit);
		1140	} else {
		1141	// We can trust the current information about this unit.
		1142	if (prev_failed) return error.AnalysisFail;
		1143	switch (nav.status) {
		1144	.unresolved => {},
		1145	.type_resolved, .fully_resolved => return,
		1146	}
		1147	}
		1148
		1149	const unit_prog_node = zcu.sema_prog_node.start(nav.fqn.toSlice(ip), 0);
		1150	defer unit_prog_node.end();
		1151
		1152	const invalidate_type: bool, const new_failed: bool = if (pt.analyzeNavType(nav_id)) \|result\| res: {
		1153	break :res .{
		1154	// If the unit has gone from failed to success, we still need to invalidate the dependencies.
		1155	result.type_changed or prev_failed,
		1156	false,
		1157	};
		1158	} else \|err\| switch (err) {
		1159	error.AnalysisFail => res: {
		1160	if (!zcu.failed_analysis.contains(anal_unit)) {
		1161	// If this unit caused the error, it would have an entry in `failed_analysis`.
		1162	// Since it does not, this must be a transitive failure.
		1163	try zcu.transitive_failed_analysis.put(gpa, anal_unit, {});
		1164	log.debug("mark transitive analysis failure for {}", .{zcu.fmtAnalUnit(anal_unit)});
		1165	}
		1166	break :res .{ !prev_failed, true };
1123	},	1167	},
1124	.resolved => \|old\| {	1168	error.OutOfMemory => {
1125	const new = ip.getNav(nav_id).status.resolved;	1169	// TODO: it's unclear how to gracefully handle this.
1126	return .{	1170	// To report the error cleanly, we need to add a message to `failed_analysis` and a
1127	.invalidate_nav_val = new.val != old.val,	1171	// corresponding entry to `retryable_failures`; but either of these things is quite
1128	.invalidate_nav_ref = ip.typeOf(new.val) != ip.typeOf(old.val) or	1172	// likely to OOM at this point.
1129	new.alignment != old.alignment or	1173	// If that happens, what do we do? Perhaps we could have a special field on `Zcu`
1130	new.@"linksection" != old.@"linksection" or	1174	// for reporting OOM errors without allocating.
1131	new.@"addrspace" != old.@"addrspace",	1175	return error.OutOfMemory;
1132	};
1133	},	1176	},
		1177	error.GenericPoison => unreachable,
		1178	error.ComptimeReturn => unreachable,
		1179	error.ComptimeBreak => unreachable,
		1180	};
		1181
		1182	if (was_outdated) {
		1183	const dependee: InternPool.Dependee = .{ .nav_ty = nav_id };
		1184	if (invalidate_type) {
		1185	// This dependency was marked as PO, meaning dependees were waiting
		1186	// on its analysis result, and it has turned out to be outdated.
		1187	// Update dependees accordingly.
		1188	try zcu.markDependeeOutdated(.marked_po, dependee);
		1189	} else {
		1190	// This dependency was previously PO, but turned out to be up-to-date.
		1191	// We do not need to queue successive analysis.
		1192	try zcu.markPoDependeeUpToDate(dependee);
		1193	}
1134	}	1194	}
		1195
		1196	if (new_failed) return error.AnalysisFail;
		1197	}
		1198
		1199	fn analyzeNavType(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Zcu.CompileError!struct { type_changed: bool } {
		1200	const zcu = pt.zcu;
		1201	const gpa = zcu.gpa;
		1202	const ip = &zcu.intern_pool;
		1203
		1204	const anal_unit: AnalUnit = .wrap(.{ .nav_ty = nav_id });
		1205	const old_nav = ip.getNav(nav_id);
		1206
		1207	log.debug("analyzeNavType {}", .{zcu.fmtAnalUnit(anal_unit)});
		1208
		1209	const inst_resolved = old_nav.analysis.?.zir_index.resolveFull(ip) orelse return error.AnalysisFail;
		1210	const file = zcu.fileByIndex(inst_resolved.file);
		1211	// TODO: stop the compiler ever reaching Sema if there are failed files. That way, this check is
		1212	// unnecessary, and we can move the below `removeDependenciesForDepender` call up with its friends
		1213	// in `ensureComptimeUnitUpToDate`.
		1214	if (file.status != .success_zir) return error.AnalysisFail;
		1215	const zir = file.zir;
		1216
		1217	// We are about to re-analyze this unit; drop its depenndencies.
		1218	zcu.intern_pool.removeDependenciesForDepender(gpa, anal_unit);
		1219
		1220	try zcu.analysis_in_progress.put(gpa, anal_unit, {});
		1221	defer _ = zcu.analysis_in_progress.swapRemove(anal_unit);
		1222
		1223	var analysis_arena: std.heap.ArenaAllocator = .init(gpa);
		1224	defer analysis_arena.deinit();
		1225
		1226	var comptime_err_ret_trace: std.ArrayList(Zcu.LazySrcLoc) = .init(gpa);
		1227	defer comptime_err_ret_trace.deinit();
		1228
		1229	var sema: Sema = .{
		1230	.pt = pt,
		1231	.gpa = gpa,
		1232	.arena = analysis_arena.allocator(),
		1233	.code = zir,
		1234	.owner = anal_unit,
		1235	.func_index = .none,
		1236	.func_is_naked = false,
		1237	.fn_ret_ty = .void,
		1238	.fn_ret_ty_ies = null,
		1239	.comptime_err_ret_trace = &comptime_err_ret_trace,
		1240	};
		1241	defer sema.deinit();
		1242
		1243	// Every `Nav` declares a dependency on the source of the corresponding declaration.
		1244	try sema.declareDependency(.{ .src_hash = old_nav.analysis.?.zir_index });
		1245
		1246	// In theory, we would also add a reference to the corresponding `nav_val` unit here: there are
		1247	// always references in both directions between a `nav_val` and `nav_ty`. However, to save memory,
		1248	// these references are known implicitly. See logic in `Zcu.resolveReferences`.
		1249
		1250	var block: Sema.Block = .{
		1251	.parent = null,
		1252	.sema = &sema,
		1253	.namespace = old_nav.analysis.?.namespace,
		1254	.instructions = .{},
		1255	.inlining = null,
		1256	.is_comptime = true,
		1257	.src_base_inst = old_nav.analysis.?.zir_index,
		1258	.type_name_ctx = old_nav.fqn,
		1259	};
		1260	defer block.instructions.deinit(gpa);
		1261
		1262	const zir_decl = zir.getDeclaration(inst_resolved.inst);
		1263	assert(old_nav.is_usingnamespace == (zir_decl.kind == .@"usingnamespace"));
		1264
		1265	const type_body = zir_decl.type_body orelse {
		1266	// The type of this `Nav` is inferred from the value.
		1267	// In other words, this `nav_ty` depends on the corresponding `nav_val`.
		1268	try sema.declareDependency(.{ .nav_val = nav_id });
		1269	try pt.ensureNavValUpToDate(nav_id);
		1270	// Note that the above call, if it did any work, has removed our `analysis_in_progress` entry for us.
		1271	// (Our `defer` will run anyway, but it does nothing in this case.)
		1272
		1273	// There's not a great way for us to know whether the type actually changed.
		1274	// For instance, perhaps the `nav_val` was already up-to-date, but this `nav_ty` is being
		1275	// analyzed because this declaration had a type annotation on the previous update.
		1276	// However, such cases are rare, and it's not unreasonable to re-analyze in them; and in
		1277	// other cases where we get here, it's because the `nav_val` was already re-analyzed and
		1278	// is outdated.
		1279	return .{ .type_changed = true };
		1280	};
		1281
		1282	const ty_src = block.src(.{ .node_offset_var_decl_ty = 0 });
		1283
		1284	const resolved_ty: Type = ty: {
		1285	const uncoerced_type_ref = try sema.resolveInlineBody(&block, type_body, inst_resolved.inst);
		1286	const type_ref = try sema.coerce(&block, .type, uncoerced_type_ref, ty_src);
		1287	break :ty .fromInterned(type_ref.toInterned().?);
		1288	};
		1289
		1290	// In the case where the type is specified, this function is also responsible for resolving
		1291	// the pointer modifiers, i.e. alignment, linksection, addrspace.
		1292	const modifiers = try sema.resolveNavPtrModifiers(&block, zir_decl, inst_resolved.inst, resolved_ty);
		1293
		1294	// Usually, we can infer this information from the resolved `Nav` value; see `Zcu.navValIsConst`.
		1295	// However, since we don't have one, we need to quickly check the ZIR to figure this out.
		1296	const is_const = switch (zir_decl.kind) {
		1297	.@"comptime" => unreachable,
		1298	.unnamed_test, .@"test", .decltest, .@"usingnamespace", .@"const" => true,
		1299	.@"var" => false,
		1300	};
		1301
		1302	const is_extern_decl = zir_decl.linkage == .@"extern";
		1303
		1304	// Now for the question of the day: are the type and modifiers the same as before?
		1305	// If they are, then we should actually keep the `Nav` as `fully_resolved` if it currently is.
		1306	// That's because `analyzeNavVal` will later want to look at the resolved value to figure out
		1307	// whether it's changed: if we threw that data away now, it would have to assume that the value
		1308	// had changed, potentially spinning off loads of unnecessary re-analysis!
		1309	const changed = switch (old_nav.status) {
		1310	.unresolved => true,
		1311	.type_resolved => \|r\| r.type != resolved_ty.toIntern() or
		1312	r.alignment != modifiers.alignment or
		1313	r.@"linksection" != modifiers.@"linksection" or
		1314	r.@"addrspace" != modifiers.@"addrspace" or
		1315	r.is_const != is_const or
		1316	r.is_extern_decl != is_extern_decl,
		1317	.fully_resolved => \|r\| ip.typeOf(r.val) != resolved_ty.toIntern() or
		1318	r.alignment != modifiers.alignment or
		1319	r.@"linksection" != modifiers.@"linksection" or
		1320	r.@"addrspace" != modifiers.@"addrspace" or
		1321	zcu.navValIsConst(r.val) != is_const or
		1322	(old_nav.getExtern(ip) != null) != is_extern_decl,
		1323	};
		1324
		1325	if (!changed) return .{ .type_changed = false };
		1326
		1327	ip.resolveNavType(nav_id, .{
		1328	.type = resolved_ty.toIntern(),
		1329	.alignment = modifiers.alignment,
		1330	.@"linksection" = modifiers.@"linksection",
		1331	.@"addrspace" = modifiers.@"addrspace",
		1332	.is_const = is_const,
		1333	.is_threadlocal = zir_decl.is_threadlocal,
		1334	.is_extern_decl = is_extern_decl,
		1335	});
		1336
		1337	return .{ .type_changed = true };
1135	}	1338	}
1136		1339
1137	pub fn ensureFuncBodyUpToDate(pt: Zcu.PerThread, maybe_coerced_func_index: InternPool.Index) Zcu.SemaError!void {	1340	pub fn ensureFuncBodyUpToDate(pt: Zcu.PerThread, maybe_coerced_func_index: InternPool.Index) Zcu.SemaError!void {
...	@@ -1144,6 +1347,8 @@ pub fn ensureFuncBodyUpToDate(pt: Zcu.PerThread, maybe_coerced_func_index: Inter	...	@@ -1144,6 +1347,8 @@ pub fn ensureFuncBodyUpToDate(pt: Zcu.PerThread, maybe_coerced_func_index: Inter
1144	const gpa = zcu.gpa;	1347	const gpa = zcu.gpa;
1145	const ip = &zcu.intern_pool;	1348	const ip = &zcu.intern_pool;
1146		1349
		1350	_ = zcu.func_body_analysis_queued.swapRemove(maybe_coerced_func_index);
		1351
1147	// We only care about the uncoerced function.	1352	// We only care about the uncoerced function.
1148	const func_index = ip.unwrapCoercedFunc(maybe_coerced_func_index);	1353	const func_index = ip.unwrapCoercedFunc(maybe_coerced_func_index);
1149	const anal_unit: AnalUnit = .wrap(.{ .func = func_index });	1354	const anal_unit: AnalUnit = .wrap(.{ .func = func_index });
...	@@ -1171,11 +1376,7 @@ pub fn ensureFuncBodyUpToDate(pt: Zcu.PerThread, maybe_coerced_func_index: Inter	...	@@ -1171,11 +1376,7 @@ pub fn ensureFuncBodyUpToDate(pt: Zcu.PerThread, maybe_coerced_func_index: Inter
1171	if (prev_failed) {	1376	if (prev_failed) {
1172	return error.AnalysisFail;	1377	return error.AnalysisFail;
1173	}	1378	}
1174	switch (func.analysisUnordered(ip).state) {	1379	if (func.analysisUnordered(ip).is_analyzed) return;
1175	.unreferenced => {}, // this is the first reference
1176	.queued => {}, // we're waiting on first-time analysis
1177	.analyzed => return, // up-to-date
1178	}
1179	}	1380	}
1180		1381
1181	const func_prog_node = zcu.sema_prog_node.start(ip.getNav(func.owner_nav).fqn.toSlice(ip), 0);	1382	const func_prog_node = zcu.sema_prog_node.start(ip.getNav(func.owner_nav).fqn.toSlice(ip), 0);
...	@@ -1236,7 +1437,7 @@ fn analyzeFuncBody(	...	@@ -1236,7 +1437,7 @@ fn analyzeFuncBody(
1236	if (func.generic_owner == .none) {	1437	if (func.generic_owner == .none) {
1237	// Among another things, this ensures that the function's `zir_body_inst` is correct.	1438	// Among another things, this ensures that the function's `zir_body_inst` is correct.
1238	try pt.ensureNavValUpToDate(func.owner_nav);	1439	try pt.ensureNavValUpToDate(func.owner_nav);
1239	if (ip.getNav(func.owner_nav).status.resolved.val != func_index) {	1440	if (ip.getNav(func.owner_nav).status.fully_resolved.val != func_index) {
1240	// This function is no longer referenced! There's no point in re-analyzing it.	1441	// This function is no longer referenced! There's no point in re-analyzing it.
1241	// Just mark a transitive failure and move on.	1442	// Just mark a transitive failure and move on.
1242	return error.AnalysisFail;	1443	return error.AnalysisFail;
...	@@ -1245,7 +1446,7 @@ fn analyzeFuncBody(	...	@@ -1245,7 +1446,7 @@ fn analyzeFuncBody(
1245	const go_nav = zcu.funcInfo(func.generic_owner).owner_nav;	1446	const go_nav = zcu.funcInfo(func.generic_owner).owner_nav;
1246	// Among another things, this ensures that the function's `zir_body_inst` is correct.	1447	// Among another things, this ensures that the function's `zir_body_inst` is correct.
1247	try pt.ensureNavValUpToDate(go_nav);	1448	try pt.ensureNavValUpToDate(go_nav);
1248	if (ip.getNav(go_nav).status.resolved.val != func.generic_owner) {	1449	if (ip.getNav(go_nav).status.fully_resolved.val != func.generic_owner) {
1249	// The generic owner is no longer referenced, so this function is also unreferenced.	1450	// The generic owner is no longer referenced, so this function is also unreferenced.
1250	// There's no point in re-analyzing it. Just mark a transitive failure and move on.	1451	// There's no point in re-analyzing it. Just mark a transitive failure and move on.
1251	return error.AnalysisFail;	1452	return error.AnalysisFail;
...	@@ -2172,7 +2373,7 @@ fn analyzeFnBodyInner(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.SemaE	...	@@ -2172,7 +2373,7 @@ fn analyzeFnBodyInner(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.SemaE
2172	try zcu.analysis_in_progress.put(gpa, anal_unit, {});	2373	try zcu.analysis_in_progress.put(gpa, anal_unit, {});
2173	errdefer _ = zcu.analysis_in_progress.swapRemove(anal_unit);	2374	errdefer _ = zcu.analysis_in_progress.swapRemove(anal_unit);
2174		2375
2175	func.setAnalysisState(ip, .analyzed);	2376	func.setAnalyzed(ip);
2176	if (func.analysisUnordered(ip).inferred_error_set) {	2377	if (func.analysisUnordered(ip).inferred_error_set) {
2177	func.setResolvedErrorSet(ip, .none);	2378	func.setResolvedErrorSet(ip, .none);
2178	}	2379	}
...	@@ -2550,8 +2751,8 @@ fn processExportsInner(	...	@@ -2550,8 +2751,8 @@ fn processExportsInner(
2550	if (zcu.transitive_failed_analysis.contains(unit)) break :failed true;	2751	if (zcu.transitive_failed_analysis.contains(unit)) break :failed true;
2551	}	2752	}
2552	const val = switch (nav.status) {	2753	const val = switch (nav.status) {
2553	.unresolved => break :failed true,	2754	.unresolved, .type_resolved => break :failed true,
2554	.resolved => \|r\| Value.fromInterned(r.val),	2755	.fully_resolved => \|r\| Value.fromInterned(r.val),
2555	};	2756	};
2556	// If the value is a function, we also need to check if that function succeeded analysis.	2757	// If the value is a function, we also need to check if that function succeeded analysis.
2557	if (val.typeOf(zcu).zigTypeTag(zcu) == .@"fn") {	2758	if (val.typeOf(zcu).zigTypeTag(zcu) == .@"fn") {
...	@@ -3256,30 +3457,29 @@ pub fn getBuiltinNav(pt: Zcu.PerThread, name: []const u8) Allocator.Error!Intern	...	@@ -3256,30 +3457,29 @@ pub fn getBuiltinNav(pt: Zcu.PerThread, name: []const u8) Allocator.Error!Intern
3256	const builtin_nav = std_namespace.pub_decls.getKeyAdapted(builtin_str, Zcu.Namespace.NameAdapter{ .zcu = zcu }) orelse	3457	const builtin_nav = std_namespace.pub_decls.getKeyAdapted(builtin_str, Zcu.Namespace.NameAdapter{ .zcu = zcu }) orelse
3257	@panic("lib/std.zig is corrupt and missing 'builtin'");	3458	@panic("lib/std.zig is corrupt and missing 'builtin'");
3258	pt.ensureNavValUpToDate(builtin_nav) catch @panic("std.builtin is corrupt");	3459	pt.ensureNavValUpToDate(builtin_nav) catch @panic("std.builtin is corrupt");
3259	const builtin_type = Type.fromInterned(ip.getNav(builtin_nav).status.resolved.val);	3460	const builtin_type = Type.fromInterned(ip.getNav(builtin_nav).status.fully_resolved.val);
3260	const builtin_namespace = zcu.namespacePtr(builtin_type.getNamespace(zcu).unwrap() orelse @panic("std.builtin is corrupt"));	3461	const builtin_namespace = zcu.namespacePtr(builtin_type.getNamespace(zcu).unwrap() orelse @panic("std.builtin is corrupt"));
3261	const name_str = try ip.getOrPutString(gpa, pt.tid, name, .no_embedded_nulls);	3462	const name_str = try ip.getOrPutString(gpa, pt.tid, name, .no_embedded_nulls);
3262	return builtin_namespace.pub_decls.getKeyAdapted(name_str, Zcu.Namespace.NameAdapter{ .zcu = zcu }) orelse @panic("lib/std/builtin.zig is corrupt");	3463	return builtin_namespace.pub_decls.getKeyAdapted(name_str, Zcu.Namespace.NameAdapter{ .zcu = zcu }) orelse @panic("lib/std/builtin.zig is corrupt");
3263	}	3464	}
3264		3465
3265	pub fn navPtrType(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) Allocator.Error!Type {	3466	pub fn navPtrType(pt: Zcu.PerThread, nav_id: InternPool.Nav.Index) Allocator.Error!Type {
3266	const zcu = pt.zcu;	3467	const zcu = pt.zcu;
3267	const ip = &zcu.intern_pool;	3468	const ip = &zcu.intern_pool;
3268	const r = ip.getNav(nav_index).status.resolved;	3469	const ty, const alignment, const @"addrspace", const is_const = switch (ip.getNav(nav_id).status) {
3269	const ty = Value.fromInterned(r.val).typeOf(zcu);	3470	.unresolved => unreachable,
		3471	.type_resolved => \|r\| .{ r.type, r.alignment, r.@"addrspace", r.is_const },
		3472	.fully_resolved => \|r\| .{ ip.typeOf(r.val), r.alignment, r.@"addrspace", zcu.navValIsConst(r.val) },
		3473	};
3270	return pt.ptrType(.{	3474	return pt.ptrType(.{
3271	.child = ty.toIntern(),	3475	.child = ty,
3272	.flags = .{	3476	.flags = .{
3273	.alignment = if (r.alignment == ty.abiAlignment(zcu))	3477	.alignment = if (alignment == Type.fromInterned(ty).abiAlignment(zcu))
3274	.none	3478	.none
3275	else	3479	else
3276	r.alignment,	3480	alignment,
3277	.address_space = r.@"addrspace",	3481	.address_space = @"addrspace",
3278	.is_const = switch (ip.indexToKey(r.val)) {	3482	.is_const = is_const,
3279	.variable => false,
3280	.@"extern" => \|e\| e.is_const,
3281	else => true,
3282	},
3283	},	3483	},
3284	});	3484	});
3285	}	3485	}
...	@@ -3299,9 +3499,13 @@ pub fn getExtern(pt: Zcu.PerThread, key: InternPool.Key.Extern) Allocator.Error!	...	@@ -3299,9 +3499,13 @@ pub fn getExtern(pt: Zcu.PerThread, key: InternPool.Key.Extern) Allocator.Error!
3299	// TODO: this shouldn't need a `PerThread`! Fix the signature of `Type.abiAlignment`.	3499	// TODO: this shouldn't need a `PerThread`! Fix the signature of `Type.abiAlignment`.
3300	pub fn navAlignment(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) InternPool.Alignment {	3500	pub fn navAlignment(pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) InternPool.Alignment {
3301	const zcu = pt.zcu;	3501	const zcu = pt.zcu;
3302	const r = zcu.intern_pool.getNav(nav_index).status.resolved;	3502	const ty: Type, const alignment = switch (zcu.intern_pool.getNav(nav_index).status) {
3303	if (r.alignment != .none) return r.alignment;	3503	.unresolved => unreachable,
3304	return Value.fromInterned(r.val).typeOf(zcu).abiAlignment(zcu);	3504	.type_resolved => \|r\| .{ .fromInterned(r.type), r.alignment },
		3505	.fully_resolved => \|r\| .{ Value.fromInterned(r.val).typeOf(zcu), r.alignment },
		3506	};
		3507	if (alignment != .none) return alignment;
		3508	return ty.abiAlignment(zcu);
3305	}	3509	}
3306		3510
3307	/// Given a container type requiring resolution, ensures that it is up-to-date.	3511	/// Given a container type requiring resolution, ensures that it is up-to-date.

src/arch/wasm/CodeGen.zig+1-9

...	@@ -3218,15 +3218,7 @@ fn lowerNavRef(func: *CodeGen, nav_index: InternPool.Nav.Index, offset: u32) Inn	...	@@ -3218,15 +3218,7 @@ fn lowerNavRef(func: *CodeGen, nav_index: InternPool.Nav.Index, offset: u32) Inn
3218	const zcu = pt.zcu;	3218	const zcu = pt.zcu;
3219	const ip = &zcu.intern_pool;	3219	const ip = &zcu.intern_pool;
3220		3220
3221	// check if decl is an alias to a function, in which case we	3221	const nav_ty = ip.getNav(nav_index).typeOf(ip);
3222	// want to lower the actual decl, rather than the alias itself.
3223	const owner_nav = switch (ip.indexToKey(zcu.navValue(nav_index).toIntern())) {
3224	.func => \|function\| function.owner_nav,
3225	.variable => \|variable\| variable.owner_nav,
3226	.@"extern" => \|@"extern"\| @"extern".owner_nav,
3227	else => nav_index,
3228	};
3229	const nav_ty = ip.getNav(owner_nav).typeOf(ip);
3230	if (!ip.isFunctionType(nav_ty) and !Type.fromInterned(nav_ty).hasRuntimeBitsIgnoreComptime(zcu)) {	3222	if (!ip.isFunctionType(nav_ty) and !Type.fromInterned(nav_ty).hasRuntimeBitsIgnoreComptime(zcu)) {
3231	return .{ .imm32 = 0xaaaaaaaa };	3223	return .{ .imm32 = 0xaaaaaaaa };
3232	}	3224	}

src/codegen.zig+9-8

...	@@ -817,7 +817,7 @@ fn genNavRef(	...	@@ -817,7 +817,7 @@ fn genNavRef(
817	pt: Zcu.PerThread,	817	pt: Zcu.PerThread,
818	src_loc: Zcu.LazySrcLoc,	818	src_loc: Zcu.LazySrcLoc,
819	val: Value,	819	val: Value,
820	ref_nav_index: InternPool.Nav.Index,	820	nav_index: InternPool.Nav.Index,
821	target: std.Target,	821	target: std.Target,
822	) CodeGenError!GenResult {	822	) CodeGenError!GenResult {
823	const zcu = pt.zcu;	823	const zcu = pt.zcu;
...	@@ -851,14 +851,15 @@ fn genNavRef(	...	@@ -851,14 +851,15 @@ fn genNavRef(
851	}	851	}
852	}	852	}
853		853
854	const nav_index, const is_extern, const lib_name, const is_threadlocal = switch (ip.indexToKey(zcu.navValue(ref_nav_index).toIntern())) {	854	const nav = ip.getNav(nav_index);
855	.func => \|func\| .{ func.owner_nav, false, .none, false },	855
856	.variable => \|variable\| .{ variable.owner_nav, false, .none, variable.is_threadlocal },	856	const is_extern, const lib_name, const is_threadlocal = if (nav.getExtern(ip)) \|e\|
857	.@"extern" => \|@"extern"\| .{ @"extern".owner_nav, true, @"extern".lib_name, @"extern".is_threadlocal },	857	.{ true, e.lib_name, e.is_threadlocal }
858	else => .{ ref_nav_index, false, .none, false },	858	else
859	};	859	.{ false, .none, nav.isThreadlocal(ip) };
		860
860	const single_threaded = zcu.navFileScope(nav_index).mod.single_threaded;	861	const single_threaded = zcu.navFileScope(nav_index).mod.single_threaded;
861	const name = ip.getNav(nav_index).name;	862	const name = nav.name;
862	if (lf.cast(.elf)) \|elf_file\| {	863	if (lf.cast(.elf)) \|elf_file\| {
863	const zo = elf_file.zigObjectPtr().?;	864	const zo = elf_file.zigObjectPtr().?;
864	if (is_extern) {	865	if (is_extern) {

src/codegen/c.zig+32-29

 @@ -770,11 +770,14 @@ pub const DeclGen = struct {
         const ctype_pool = &dg.ctype_pool;
         // Chase function values in order to be able to reference the original function.
-        const owner_nav = switch (ip.indexToKey(zcu.navValue(nav_index).toIntern())) {
+        const owner_nav = switch (ip.getNav(nav_index).status) {
-            .variable => |variable| variable.owner_nav,
+            .unresolved => unreachable,
-            .func => |func| func.owner_nav,
+            .type_resolved => nav_index, // this can't be an extern or a function
-            .@"extern" => |@"extern"| @"extern".owner_nav,
+            .fully_resolved => |r| switch (ip.indexToKey(r.val)) {
-            else => nav_index,
+                .func => |f| f.owner_nav,
+                .@"extern" => |e| e.owner_nav,
+                else => nav_index,
+            },
         };
         // Render an undefined pointer if we have a pointer to a zero-bit or comptime type.
 @@ -2237,7 +2240,7 @@ pub const DeclGen = struct {
             Type.fromInterned(nav.typeOf(ip)),
             .{ .nav = nav_index },
             CQualifiers.init(.{ .@"const" = flags.is_const }),
-            nav.status.resolved.alignment,
+            nav.getAlignment(),
             .complete,
         );
         try fwd.writeAll(";\n");
 @@ -2246,19 +2249,19 @@ pub const DeclGen = struct {
     fn renderNavName(dg: *DeclGen, writer: anytype, nav_index: InternPool.Nav.Index) !void {
         const zcu = dg.pt.zcu;
         const ip = &zcu.intern_pool;
-        switch (ip.indexToKey(zcu.navValue(nav_index).toIntern())) {
+        const nav = ip.getNav(nav_index);
-            .@"extern" => |@"extern"| try writer.print("{ }", .{
+        if (nav.getExtern(ip)) |@"extern"| {
+            try writer.print("{ }", .{
                 fmtIdent(ip.getNav(@"extern".owner_nav).name.toSlice(ip)),
-            }),
+            });
-            else => {
+        } else {
-                // MSVC has a limit of 4095 character token length limit, and fmtIdent can (worst case),
+            // MSVC has a limit of 4095 character token length limit, and fmtIdent can (worst case),
-                // expand to 3x the length of its input, but let's cut it off at a much shorter limit.
+            // expand to 3x the length of its input, but let's cut it off at a much shorter limit.
-                const fqn_slice = ip.getNav(nav_index).fqn.toSlice(ip);
+            const fqn_slice = ip.getNav(nav_index).fqn.toSlice(ip);
-                try writer.print("{}__{d}", .{
+            try writer.print("{}__{d}", .{
-                    fmtIdent(fqn_slice[0..@min(fqn_slice.len, 100)]),
+                fmtIdent(fqn_slice[0..@min(fqn_slice.len, 100)]),
-                    @intFromEnum(nav_index),
+                @intFromEnum(nav_index),
-                });
+            });
-            },
         }
     }
 @@ -2826,7 +2829,7 @@ pub fn genLazyFn(o: *Object, lazy_ctype_pool: *const CType.Pool, lazy_fn: LazyFn
             const fwd = o.dg.fwdDeclWriter();
             try fwd.print("static zig_{s} ", .{@tagName(key)});
-            try o.dg.renderFunctionSignature(fwd, fn_val, ip.getNav(fn_nav_index).status.resolved.alignment, .forward, .{
+            try o.dg.renderFunctionSignature(fwd, fn_val, ip.getNav(fn_nav_index).getAlignment(), .forward, .{
                 .fmt_ctype_pool_string = fn_name,
             });
             try fwd.writeAll(";\n");
 @@ -2867,13 +2870,13 @@ pub fn genFunc(f: *Function) !void {
     try o.dg.renderFunctionSignature(
         fwd,
         nav_val,
-        nav.status.resolved.alignment,
+        nav.status.fully_resolved.alignment,
         .forward,
         .{ .nav = nav_index },
     );
     try fwd.writeAll(";\n");
-    if (nav.status.resolved.@"linksection".toSlice(ip)) |s|
+    if (nav.status.fully_resolved.@"linksection".toSlice(ip)) |s|
         try o.writer().print("zig_linksection_fn({s}) ", .{fmtStringLiteral(s, null)});
     try o.dg.renderFunctionSignature(
         o.writer(),
 @@ -2952,7 +2955,7 @@ pub fn genDecl(o: *Object) !void {
     const nav_ty = Type.fromInterned(nav.typeOf(ip));
     if (!nav_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) return;
-    switch (ip.indexToKey(nav.status.resolved.val)) {
+    switch (ip.indexToKey(nav.status.fully_resolved.val)) {
         .@"extern" => |@"extern"| {
             if (!ip.isFunctionType(nav_ty.toIntern())) return o.dg.renderFwdDecl(o.dg.pass.nav, .{
                 .is_extern = true,
 @@ -2965,8 +2968,8 @@ pub fn genDecl(o: *Object) !void {
             try fwd.writeAll("zig_extern ");
             try o.dg.renderFunctionSignature(
                 fwd,
-                Value.fromInterned(nav.status.resolved.val),
+                Value.fromInterned(nav.status.fully_resolved.val),
-                nav.status.resolved.alignment,
+                nav.status.fully_resolved.alignment,
                 .forward,
                 .{ .@"export" = .{
                     .main_name = nav.name,
 @@ -2985,14 +2988,14 @@ pub fn genDecl(o: *Object) !void {
             const w = o.writer();
             if (variable.is_weak_linkage) try w.writeAll("zig_weak_linkage ");
             if (variable.is_threadlocal and !o.dg.mod.single_threaded) try w.writeAll("zig_threadlocal ");
-            if (nav.status.resolved.@"linksection".toSlice(&zcu.intern_pool)) |s|
+            if (nav.status.fully_resolved.@"linksection".toSlice(&zcu.intern_pool)) |s|
                 try w.print("zig_linksection({s}) ", .{fmtStringLiteral(s, null)});
             try o.dg.renderTypeAndName(
                 w,
                 nav_ty,
                 .{ .nav = o.dg.pass.nav },
                 .{},
-                nav.status.resolved.alignment,
+                nav.status.fully_resolved.alignment,
                 .complete,
             );
             try w.writeAll(" = ");
 @@ -3002,10 +3005,10 @@ pub fn genDecl(o: *Object) !void {
         },
         else => try genDeclValue(
             o,
-            Value.fromInterned(nav.status.resolved.val),
+            Value.fromInterned(nav.status.fully_resolved.val),
             .{ .nav = o.dg.pass.nav },
-            nav.status.resolved.alignment,
+            nav.status.fully_resolved.alignment,
-            nav.status.resolved.@"linksection",
+            nav.status.fully_resolved.@"linksection",
         ),
     }
 }

src/codegen/llvm.zig+28-36

 @@ -1476,7 +1476,7 @@ pub const Object = struct {
             } }, &o.builder);
         }
-        if (nav.status.resolved.@"linksection".toSlice(ip)) |section|
+        if (nav.status.fully_resolved.@"linksection".toSlice(ip)) |section|
             function_index.setSection(try o.builder.string(section), &o.builder);
         var deinit_wip = true;
 @@ -1684,7 +1684,7 @@ pub const Object = struct {
             const file = try o.getDebugFile(file_scope);
             const line_number = zcu.navSrcLine(func.owner_nav) + 1;
-            const is_internal_linkage = ip.indexToKey(nav.status.resolved.val) != .@"extern";
+            const is_internal_linkage = ip.indexToKey(nav.status.fully_resolved.val) != .@"extern";
             const debug_decl_type = try o.lowerDebugType(fn_ty);
             const subprogram = try o.builder.debugSubprogram(
 @@ -2928,9 +2928,7 @@ pub const Object = struct {
         const gpa = o.gpa;
         const nav = ip.getNav(nav_index);
         const owner_mod = zcu.navFileScope(nav_index).mod;
-        const resolved = nav.status.resolved;
+        const ty: Type = .fromInterned(nav.typeOf(ip));
-        const val = Value.fromInterned(resolved.val);
-        const ty = val.typeOf(zcu);
         const gop = try o.nav_map.getOrPut(gpa, nav_index);
         if (gop.found_existing) return gop.value_ptr.ptr(&o.builder).kind.function;
 @@ -2938,14 +2936,14 @@ pub const Object = struct {
         const target = owner_mod.resolved_target.result;
         const sret = firstParamSRet(fn_info, zcu, target);
-        const is_extern, const lib_name = switch (ip.indexToKey(val.toIntern())) {
+        const is_extern, const lib_name = if (nav.getExtern(ip)) |@"extern"|
-            .@"extern" => |@"extern"| .{ true, @"extern".lib_name },
+            .{ true, @"extern".lib_name }
-            else => .{ false, .none },
+        else
-        };
+            .{ false, .none };
         const function_index = try o.builder.addFunction(
             try o.lowerType(ty),
             try o.builder.strtabString((if (is_extern) nav.name else nav.fqn).toSlice(ip)),
-            toLlvmAddressSpace(resolved.@"addrspace", target),
+            toLlvmAddressSpace(nav.getAddrspace(), target),
         );
         gop.value_ptr.* = function_index.ptrConst(&o.builder).global;
 @@ -3063,8 +3061,8 @@ pub const Object = struct {
             }
         }
-        if (resolved.alignment != .none)
+        if (nav.getAlignment() != .none)
-            function_index.setAlignment(resolved.alignment.toLlvm(), &o.builder);
+            function_index.setAlignment(nav.getAlignment().toLlvm(), &o.builder);
         // Function attributes that are independent of analysis results of the function body.
         try o.addCommonFnAttributes(
 @@ -3249,17 +3247,21 @@ pub const Object = struct {
         const zcu = pt.zcu;
         const ip = &zcu.intern_pool;
         const nav = ip.getNav(nav_index);
-        const resolved = nav.status.resolved;
+        const is_extern, const is_threadlocal, const is_weak_linkage, const is_dll_import = switch (nav.status) {
-        const is_extern, const is_threadlocal, const is_weak_linkage, const is_dll_import = switch (ip.indexToKey(resolved.val)) {
+            .unresolved => unreachable,
-            .variable => |variable| .{ false, variable.is_threadlocal, variable.is_weak_linkage, false },
+            .fully_resolved => |r| switch (ip.indexToKey(r.val)) {
-            .@"extern" => |@"extern"| .{ true, @"extern".is_threadlocal, @"extern".is_weak_linkage, @"extern".is_dll_import },
+                .variable => |variable| .{ false, variable.is_threadlocal, variable.is_weak_linkage, false },
-            else => .{ false, false, false, false },
+                .@"extern" => |@"extern"| .{ true, @"extern".is_threadlocal, @"extern".is_weak_linkage, @"extern".is_dll_import },
+                else => .{ false, false, false, false },
+            },
+            // This means it's a source declaration which is not `extern`!
+            .type_resolved => |r| .{ false, r.is_threadlocal, false, false },
         };
         const variable_index = try o.builder.addVariable(
             try o.builder.strtabString((if (is_extern) nav.name else nav.fqn).toSlice(ip)),
             try o.lowerType(Type.fromInterned(nav.typeOf(ip))),
-            toLlvmGlobalAddressSpace(resolved.@"addrspace", zcu.getTarget()),
+            toLlvmGlobalAddressSpace(nav.getAddrspace(), zcu.getTarget()),
         );
         gop.value_ptr.* = variable_index.ptrConst(&o.builder).global;
 @@ -4528,20 +4530,10 @@ pub const Object = struct {
         const zcu = pt.zcu;
         const ip = &zcu.intern_pool;
-        // In the case of something like:
+        const nav = ip.getNav(nav_index);
-        // fn foo() void {}
-        // const bar = foo;
-        // ... &bar;
-        // `bar` is just an alias and we actually want to lower a reference to `foo`.
-        const owner_nav_index = switch (ip.indexToKey(zcu.navValue(nav_index).toIntern())) {
-            .func => |func| func.owner_nav,
-            .@"extern" => |@"extern"| @"extern".owner_nav,
-            else => nav_index,
-        };
-        const owner_nav = ip.getNav(owner_nav_index);
-        const nav_ty = Type.fromInterned(owner_nav.typeOf(ip));
+        const nav_ty = Type.fromInterned(nav.typeOf(ip));
-        const ptr_ty = try pt.navPtrType(owner_nav_index);
+        const ptr_ty = try pt.navPtrType(nav_index);
         const is_fn_body = nav_ty.zigTypeTag(zcu) == .@"fn";
         if ((!is_fn_body and !nav_ty.hasRuntimeBits(zcu)) or
 @@ -4551,13 +4543,13 @@ pub const Object = struct {
         }
         const llvm_global = if (is_fn_body)
-            (try o.resolveLlvmFunction(owner_nav_index)).ptrConst(&o.builder).global
+            (try o.resolveLlvmFunction(nav_index)).ptrConst(&o.builder).global
         else
-            (try o.resolveGlobalNav(owner_nav_index)).ptrConst(&o.builder).global;
+            (try o.resolveGlobalNav(nav_index)).ptrConst(&o.builder).global;
         const llvm_val = try o.builder.convConst(
             llvm_global.toConst(),
-            try o.builder.ptrType(toLlvmAddressSpace(owner_nav.status.resolved.@"addrspace", zcu.getTarget())),
+            try o.builder.ptrType(toLlvmAddressSpace(nav.getAddrspace(), zcu.getTarget())),
         );
         return o.builder.convConst(llvm_val, try o.lowerType(ptr_ty));
 @@ -4799,7 +4791,7 @@ pub const NavGen = struct {
         const ip = &zcu.intern_pool;
         const nav_index = ng.nav_index;
         const nav = ip.getNav(nav_index);
-        const resolved = nav.status.resolved;
+        const resolved = nav.status.fully_resolved;
         const is_extern, const lib_name, const is_threadlocal, const is_weak_linkage, const is_dll_import, const is_const, const init_val, const owner_nav = switch (ip.indexToKey(resolved.val)) {
             .variable => |variable| .{ false, .none, variable.is_threadlocal, variable.is_weak_linkage, false, false, variable.init, variable.owner_nav },
 @@ -5765,7 +5757,7 @@ pub const FuncGen = struct {
         const msg_nav_index = zcu.panic_messages[@intFromEnum(panic_id)].unwrap().?;
         const msg_nav = ip.getNav(msg_nav_index);
         const msg_len = Type.fromInterned(msg_nav.typeOf(ip)).childType(zcu).arrayLen(zcu);
-        const msg_ptr = try o.lowerValue(msg_nav.status.resolved.val);
+        const msg_ptr = try o.lowerValue(msg_nav.status.fully_resolved.val);
         const null_opt_addr_global = try fg.resolveNullOptUsize();
         const target = zcu.getTarget();
         const llvm_usize = try o.lowerType(Type.usize);

src/codegen/spirv.zig+16-13

...	@@ -268,7 +268,7 @@ pub const Object = struct {	...	@@ -268,7 +268,7 @@ pub const Object = struct {
268	// TODO: Extern fn?	268	// TODO: Extern fn?
269	const kind: SpvModule.Decl.Kind = if (ip.isFunctionType(nav.typeOf(ip)))	269	const kind: SpvModule.Decl.Kind = if (ip.isFunctionType(nav.typeOf(ip)))
270	.func	270	.func
271	else switch (nav.status.resolved.@"addrspace") {	271	else switch (nav.getAddrspace()) {
272	.generic => .invocation_global,	272	.generic => .invocation_global,
273	else => .global,	273	else => .global,
274	};	274	};
...	@@ -1279,17 +1279,20 @@ const NavGen = struct {	...	@@ -1279,17 +1279,20 @@ const NavGen = struct {
1279	const ip = &zcu.intern_pool;	1279	const ip = &zcu.intern_pool;
1280	const ty_id = try self.resolveType(ty, .direct);	1280	const ty_id = try self.resolveType(ty, .direct);
1281	const nav = ip.getNav(nav_index);	1281	const nav = ip.getNav(nav_index);
1282	const nav_val = zcu.navValue(nav_index);	1282	const nav_ty: Type = .fromInterned(nav.typeOf(ip));
1283	const nav_ty = nav_val.typeOf(zcu);	1283
1284		1284	switch (nav.status) {
1285	switch (ip.indexToKey(nav_val.toIntern())) {	1285	.unresolved => unreachable,
1286	.func => {	1286	.type_resolved => {}, // this is not a function or extern
1287	// TODO: Properly lower function pointers. For now we are going to hack around it and	1287	.fully_resolved => \|r\| switch (ip.indexToKey(r.val)) {
1288	// just generate an empty pointer. Function pointers are represented by a pointer to usize.	1288	.func => {
1289	return try self.spv.constUndef(ty_id);	1289	// TODO: Properly lower function pointers. For now we are going to hack around it and
		1290	// just generate an empty pointer. Function pointers are represented by a pointer to usize.
		1291	return try self.spv.constUndef(ty_id);
		1292	},
		1293	.@"extern" => if (ip.isFunctionType(nav_ty.toIntern())) @panic("TODO"),
		1294	else => {},
1290	},	1295	},
1291	.@"extern" => assert(!ip.isFunctionType(nav_ty.toIntern())), // TODO
1292	else => {},
1293	}	1296	}
1294		1297
1295	if (!nav_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) {	1298	if (!nav_ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) {
...	@@ -1305,7 +1308,7 @@ const NavGen = struct {	...	@@ -1305,7 +1308,7 @@ const NavGen = struct {
1305	.global, .invocation_global => spv_decl.result_id,	1308	.global, .invocation_global => spv_decl.result_id,
1306	};	1309	};
1307		1310
1308	const storage_class = self.spvStorageClass(nav.status.resolved.@"addrspace");	1311	const storage_class = self.spvStorageClass(nav.getAddrspace());
1309	try self.addFunctionDep(spv_decl_index, storage_class);	1312	try self.addFunctionDep(spv_decl_index, storage_class);
1310		1313
1311	const decl_ptr_ty_id = try self.ptrType(nav_ty, storage_class);	1314	const decl_ptr_ty_id = try self.ptrType(nav_ty, storage_class);
...	@@ -3182,7 +3185,7 @@ const NavGen = struct {	...	@@ -3182,7 +3185,7 @@ const NavGen = struct {
3182	};	3185	};
3183	assert(maybe_init_val == null); // TODO	3186	assert(maybe_init_val == null); // TODO
3184		3187
3185	const storage_class = self.spvStorageClass(nav.status.resolved.@"addrspace");	3188	const storage_class = self.spvStorageClass(nav.getAddrspace());
3186	assert(storage_class != .Generic); // These should be instance globals	3189	assert(storage_class != .Generic); // These should be instance globals
3187		3190
3188	const ptr_ty_id = try self.ptrType(ty, storage_class);	3191	const ptr_ty_id = try self.ptrType(ty, storage_class);

src/link.zig+1-1

...	@@ -692,7 +692,7 @@ pub const File = struct {	...	@@ -692,7 +692,7 @@ pub const File = struct {
692	/// May be called before or after updateExports for any given Nav.	692	/// May be called before or after updateExports for any given Nav.
693	pub fn updateNav(base: *File, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) UpdateNavError!void {	693	pub fn updateNav(base: *File, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) UpdateNavError!void {
694	const nav = pt.zcu.intern_pool.getNav(nav_index);	694	const nav = pt.zcu.intern_pool.getNav(nav_index);
695	assert(nav.status == .resolved);	695	assert(nav.status == .fully_resolved);
696	switch (base.tag) {	696	switch (base.tag) {
697	inline else => \|tag\| {	697	inline else => \|tag\| {
698	dev.check(tag.devFeature());	698	dev.check(tag.devFeature());

src/link/C.zig+9-11

 @@ -217,7 +217,7 @@ pub fn updateFunc(
                 .mod = zcu.navFileScope(func.owner_nav).mod,
                 .error_msg = null,
                 .pass = .{ .nav = func.owner_nav },
-                .is_naked_fn = zcu.navValue(func.owner_nav).typeOf(zcu).fnCallingConvention(zcu) == .naked,
+                .is_naked_fn = Type.fromInterned(func.ty).fnCallingConvention(zcu) == .naked,
                 .fwd_decl = fwd_decl.toManaged(gpa),
                 .ctype_pool = ctype_pool.*,
                 .scratch = .{},
 @@ -320,11 +320,11 @@ pub fn updateNav(self: *C, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) !
     const ip = &zcu.intern_pool;
     const nav = ip.getNav(nav_index);
-    const nav_init = switch (ip.indexToKey(nav.status.resolved.val)) {
+    const nav_init = switch (ip.indexToKey(nav.status.fully_resolved.val)) {
         .func => return,
         .@"extern" => .none,
         .variable => |variable| variable.init,
-        else => nav.status.resolved.val,
+        else => nav.status.fully_resolved.val,
     };
     if (nav_init != .none and !Value.fromInterned(nav_init).typeOf(zcu).hasRuntimeBits(zcu)) return;
 @@ -499,7 +499,7 @@ pub fn flushModule(self: *C, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
             av_block,
             self.exported_navs.getPtr(nav),
             export_names,
-            if (ip.indexToKey(zcu.navValue(nav).toIntern()) == .@"extern")
+            if (ip.getNav(nav).getExtern(ip) != null)
                 ip.getNav(nav).name.toOptional()
             else
                 .none,
 @@ -544,13 +544,11 @@ pub fn flushModule(self: *C, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
         },
         self.getString(av_block.code),
     );
-    for (self.navs.keys(), self.navs.values()) |nav, av_block| f.appendCodeAssumeCapacity(
+    for (self.navs.keys(), self.navs.values()) |nav, av_block| f.appendCodeAssumeCapacity(storage: {
-        if (self.exported_navs.contains(nav)) .default else switch (ip.indexToKey(zcu.navValue(nav).toIntern())) {
+        if (self.exported_navs.contains(nav)) break :storage .default;
-            .@"extern" => .zig_extern,
+        if (ip.getNav(nav).getExtern(ip) != null) break :storage .zig_extern;
-            else => .static,
+        break :storage .static;
-        },
+    }, self.getString(av_block.code));
-        self.getString(av_block.code),
-    );
     const file = self.base.file.?;
     try file.setEndPos(f.file_size);

src/link/Coff.zig+11-6

...	@@ -1110,6 +1110,8 @@ pub fn updateFunc(coff: *Coff, pt: Zcu.PerThread, func_index: InternPool.Index,	...	@@ -1110,6 +1110,8 @@ pub fn updateFunc(coff: *Coff, pt: Zcu.PerThread, func_index: InternPool.Index,
1110	const atom_index = try coff.getOrCreateAtomForNav(func.owner_nav);	1110	const atom_index = try coff.getOrCreateAtomForNav(func.owner_nav);
1111	coff.freeRelocations(atom_index);	1111	coff.freeRelocations(atom_index);
1112		1112
		1113	coff.navs.getPtr(func.owner_nav).?.section = coff.text_section_index.?;
		1114
1113	var code_buffer = std.ArrayList(u8).init(gpa);	1115	var code_buffer = std.ArrayList(u8).init(gpa);
1114	defer code_buffer.deinit();	1116	defer code_buffer.deinit();
1115		1117
...	@@ -1223,6 +1225,8 @@ pub fn updateNav(	...	@@ -1223,6 +1225,8 @@ pub fn updateNav(
1223	coff.freeRelocations(atom_index);	1225	coff.freeRelocations(atom_index);
1224	const atom = coff.getAtom(atom_index);	1226	const atom = coff.getAtom(atom_index);
1225		1227
		1228	coff.navs.getPtr(nav_index).?.section = coff.getNavOutputSection(nav_index);
		1229
1226	var code_buffer = std.ArrayList(u8).init(gpa);	1230	var code_buffer = std.ArrayList(u8).init(gpa);
1227	defer code_buffer.deinit();	1231	defer code_buffer.deinit();
1228		1232
...	@@ -1342,7 +1346,8 @@ pub fn getOrCreateAtomForNav(coff: *Coff, nav_index: InternPool.Nav.Index) !Atom	...	@@ -1342,7 +1346,8 @@ pub fn getOrCreateAtomForNav(coff: *Coff, nav_index: InternPool.Nav.Index) !Atom
1342	if (!gop.found_existing) {	1346	if (!gop.found_existing) {
1343	gop.value_ptr.* = .{	1347	gop.value_ptr.* = .{
1344	.atom = try coff.createAtom(),	1348	.atom = try coff.createAtom(),
1345	.section = coff.getNavOutputSection(nav_index),	1349	// If necessary, this will be modified by `updateNav` or `updateFunc`.
		1350	.section = coff.rdata_section_index.?,
1346	.exports = .{},	1351	.exports = .{},
1347	};	1352	};
1348	}	1353	}
...	@@ -1355,7 +1360,7 @@ fn getNavOutputSection(coff: *Coff, nav_index: InternPool.Nav.Index) u16 {	...	@@ -1355,7 +1360,7 @@ fn getNavOutputSection(coff: *Coff, nav_index: InternPool.Nav.Index) u16 {
1355	const nav = ip.getNav(nav_index);	1360	const nav = ip.getNav(nav_index);
1356	const ty = Type.fromInterned(nav.typeOf(ip));	1361	const ty = Type.fromInterned(nav.typeOf(ip));
1357	const zig_ty = ty.zigTypeTag(zcu);	1362	const zig_ty = ty.zigTypeTag(zcu);
1358	const val = Value.fromInterned(nav.status.resolved.val);	1363	const val = Value.fromInterned(nav.status.fully_resolved.val);
1359	const index: u16 = blk: {	1364	const index: u16 = blk: {
1360	if (val.isUndefDeep(zcu)) {	1365	if (val.isUndefDeep(zcu)) {
1361	// TODO in release-fast and release-small, we should put undef in .bss	1366	// TODO in release-fast and release-small, we should put undef in .bss
...	@@ -2348,10 +2353,10 @@ pub fn getNavVAddr(	...	@@ -2348,10 +2353,10 @@ pub fn getNavVAddr(
2348	const ip = &zcu.intern_pool;	2353	const ip = &zcu.intern_pool;
2349	const nav = ip.getNav(nav_index);	2354	const nav = ip.getNav(nav_index);
2350	log.debug("getNavVAddr {}({d})", .{ nav.fqn.fmt(ip), nav_index });	2355	log.debug("getNavVAddr {}({d})", .{ nav.fqn.fmt(ip), nav_index });
2351	const sym_index = switch (ip.indexToKey(nav.status.resolved.val)) {	2356	const sym_index = if (nav.getExtern(ip)) \|e\|
2352	.@"extern" => \|@"extern"\| try coff.getGlobalSymbol(nav.name.toSlice(ip), @"extern".lib_name.toSlice(ip)),	2357	try coff.getGlobalSymbol(nav.name.toSlice(ip), e.lib_name.toSlice(ip))
2353	else => coff.getAtom(try coff.getOrCreateAtomForNav(nav_index)).getSymbolIndex().?,	2358	else
2354	};	2359	coff.getAtom(try coff.getOrCreateAtomForNav(nav_index)).getSymbolIndex().?;
2355	const atom_index = coff.getAtomIndexForSymbol(.{	2360	const atom_index = coff.getAtomIndexForSymbol(.{
2356	.sym_index = reloc_info.parent.atom_index,	2361	.sym_index = reloc_info.parent.atom_index,
2357	.file = null,	2362	.file = null,

src/link/Dwarf.zig+5-5

src/link/Elf/ZigObject.zig+10-15

 @@ -925,14 +925,11 @@ pub fn getNavVAddr(
     const ip = &zcu.intern_pool;
     const nav = ip.getNav(nav_index);
     log.debug("getNavVAddr {}({d})", .{ nav.fqn.fmt(ip), nav_index });
-    const this_sym_index = switch (ip.indexToKey(nav.status.resolved.val)) {
+    const this_sym_index = if (nav.getExtern(ip)) |@"extern"| try self.getGlobalSymbol(
-        .@"extern" => |@"extern"| try self.getGlobalSymbol(
+        elf_file,
-            elf_file,
+        nav.name.toSlice(ip),
-            nav.name.toSlice(ip),
+        @"extern".lib_name.toSlice(ip),
-            @"extern".lib_name.toSlice(ip),
+    ) else try self.getOrCreateMetadataForNav(zcu, nav_index);
-        ),
-        else => try self.getOrCreateMetadataForNav(zcu, nav_index),
-    };
     const this_sym = self.symbol(this_sym_index);
     const vaddr = this_sym.address(.{}, elf_file);
     switch (reloc_info.parent) {
 @@ -1107,15 +1104,13 @@ pub fn freeNav(self: *ZigObject, elf_file: *Elf, nav_index: InternPool.Nav.Index
 pub fn getOrCreateMetadataForNav(self: *ZigObject, zcu: *Zcu, nav_index: InternPool.Nav.Index) !Symbol.Index {
     const gpa = zcu.gpa;
+    const ip = &zcu.intern_pool;
     const gop = try self.navs.getOrPut(gpa, nav_index);
     if (!gop.found_existing) {
         const symbol_index = try self.newSymbolWithAtom(gpa, 0);
-        const nav_val = Value.fromInterned(zcu.intern_pool.getNav(nav_index).status.resolved.val);
         const sym = self.symbol(symbol_index);
-        if (nav_val.getVariable(zcu)) |variable| {
+        if (ip.getNav(nav_index).isThreadlocal(ip) and zcu.comp.config.any_non_single_threaded) {
-            if (variable.is_threadlocal and zcu.comp.config.any_non_single_threaded) {
+            sym.flags.is_tls = true;
-                sym.flags.is_tls = true;
-            }
         }
         gop.value_ptr.* = .{ .symbol_index = symbol_index };
     }
 @@ -1547,7 +1542,7 @@ pub fn updateNav(
     log.debug("updateNav {}({d})", .{ nav.fqn.fmt(ip), nav_index });
-    const nav_init = switch (ip.indexToKey(nav.status.resolved.val)) {
+    const nav_init = switch (ip.indexToKey(nav.status.fully_resolved.val)) {
         .func => .none,
         .variable => |variable| variable.init,
         .@"extern" => |@"extern"| {
 @@ -1560,7 +1555,7 @@ pub fn updateNav(
             self.symbol(sym_index).flags.is_extern_ptr = true;
             return;
         },
-        else => nav.status.resolved.val,
+        else => nav.status.fully_resolved.val,
     };
     if (nav_init != .none and Value.fromInterned(nav_init).typeOf(zcu).hasRuntimeBits(zcu)) {

src/link/MachO/ZigObject.zig+8-15

 @@ -608,14 +608,11 @@ pub fn getNavVAddr(
     const ip = &zcu.intern_pool;
     const nav = ip.getNav(nav_index);
     log.debug("getNavVAddr {}({d})", .{ nav.fqn.fmt(ip), nav_index });
-    const sym_index = switch (ip.indexToKey(nav.status.resolved.val)) {
+    const sym_index = if (nav.getExtern(ip)) |@"extern"| try self.getGlobalSymbol(
-        .@"extern" => |@"extern"| try self.getGlobalSymbol(
+        macho_file,
-            macho_file,
+        nav.name.toSlice(ip),
-            nav.name.toSlice(ip),
+        @"extern".lib_name.toSlice(ip),
-            @"extern".lib_name.toSlice(ip),
+    ) else try self.getOrCreateMetadataForNav(macho_file, nav_index);
-        ),
-        else => try self.getOrCreateMetadataForNav(macho_file, nav_index),
-    };
     const sym = self.symbols.items[sym_index];
     const vaddr = sym.getAddress(.{}, macho_file);
     switch (reloc_info.parent) {
 @@ -882,7 +879,7 @@ pub fn updateNav(
     const ip = &zcu.intern_pool;
     const nav = ip.getNav(nav_index);
-    const nav_init = switch (ip.indexToKey(nav.status.resolved.val)) {
+    const nav_init = switch (ip.indexToKey(nav.status.fully_resolved.val)) {
         .func => .none,
         .variable => |variable| variable.init,
         .@"extern" => |@"extern"| {
 @@ -895,7 +892,7 @@ pub fn updateNav(
             sym.flags.is_extern_ptr = true;
             return;
         },
-        else => nav.status.resolved.val,
+        else => nav.status.fully_resolved.val,
     };
     if (nav_init != .none and Value.fromInterned(nav_init).typeOf(zcu).hasRuntimeBits(zcu)) {
 @@ -1561,11 +1558,7 @@ fn isThreadlocal(macho_file: *MachO, nav_index: InternPool.Nav.Index) bool {
     if (!macho_file.base.comp.config.any_non_single_threaded)
         return false;
     const ip = &macho_file.base.comp.zcu.?.intern_pool;
-    return switch (ip.indexToKey(ip.getNav(nav_index).status.resolved.val)) {
+    return ip.getNav(nav_index).isThreadlocal(ip);
-        .variable => |variable| variable.is_threadlocal,
-        .@"extern" => |@"extern"| @"extern".is_threadlocal,
-        else => false,
-    };
 }
 fn addAtom(self: *ZigObject, allocator: Allocator) !Atom.Index {

src/link/Plan9.zig+2-2

src/link/Wasm/ZigObject.zig+6-7

 @@ -734,15 +734,14 @@ pub fn getNavVAddr(
     const target_atom_index = try zig_object.getOrCreateAtomForNav(wasm, pt, nav_index);
     const target_atom = wasm.getAtom(target_atom_index);
     const target_symbol_index = @intFromEnum(target_atom.sym_index);
-    switch (ip.indexToKey(nav.status.resolved.val)) {
+    if (nav.getExtern(ip)) |@"extern"| {
-        .@"extern" => |@"extern"| try zig_object.addOrUpdateImport(
+        try zig_object.addOrUpdateImport(
             wasm,
             nav.name.toSlice(ip),
             target_atom.sym_index,
             @"extern".lib_name.toSlice(ip),
             null,
-        ),
+        );
-        else => {},
     }
     std.debug.assert(reloc_info.parent.atom_index != 0);
 @@ -945,8 +944,8 @@ pub fn freeNav(zig_object: *ZigObject, wasm: *Wasm, nav_index: InternPool.Nav.In
         segment.name = &.{}; // Ensure no accidental double free
     }
-    const nav_val = zcu.navValue(nav_index).toIntern();
+    const nav = ip.getNav(nav_index);
-    if (ip.indexToKey(nav_val) == .@"extern") {
+    if (nav.getExtern(ip) != null) {
         std.debug.assert(zig_object.imports.remove(atom.sym_index));
     }
     std.debug.assert(wasm.symbol_atom.remove(atom.symbolLoc()));
 @@ -960,7 +959,7 @@ pub fn freeNav(zig_object: *ZigObject, wasm: *Wasm, nav_index: InternPool.Nav.In
     if (sym.isGlobal()) {
         std.debug.assert(zig_object.global_syms.remove(atom.sym_index));
     }
-    if (ip.isFunctionType(ip.typeOf(nav_val))) {
+    if (ip.isFunctionType(nav.typeOf(ip))) {
         zig_object.functions_free_list.append(gpa, sym.index) catch {};
         std.debug.assert(zig_object.atom_types.remove(atom_index));
     } else {

test/behavior/globals.zig+96

...	@@ -66,3 +66,99 @@ test "global loads can affect liveness" {	...	@@ -66,3 +66,99 @@ test "global loads can affect liveness" {
66	S.f();	66	S.f();
67	try std.testing.expect(y.a == 1);	67	try std.testing.expect(y.a == 1);
68	}	68	}
		69
		70	test "global const can be self-referential" {
		71	const S = struct {
		72	self: *const @This(),
		73	x: u32,
		74
		75	const foo: @This() = .{ .self = &foo, .x = 123 };
		76	};
		77
		78	try std.testing.expect(S.foo.x == 123);
		79	try std.testing.expect(S.foo.self.x == 123);
		80	try std.testing.expect(S.foo.self.self.x == 123);
		81	try std.testing.expect(S.foo.self == &S.foo);
		82	try std.testing.expect(S.foo.self.self == &S.foo);
		83	}
		84
		85	test "global var can be self-referential" {
		86	const S = struct {
		87	self: *@This(),
		88	x: u32,
		89
		90	var foo: @This() = .{ .self = &foo, .x = undefined };
		91	};
		92
		93	S.foo.x = 123;
		94
		95	try std.testing.expect(S.foo.x == 123);
		96	try std.testing.expect(S.foo.self.x == 123);
		97	try std.testing.expect(S.foo.self == &S.foo);
		98
		99	S.foo.self.x = 456;
		100
		101	try std.testing.expect(S.foo.x == 456);
		102	try std.testing.expect(S.foo.self.x == 456);
		103	try std.testing.expect(S.foo.self == &S.foo);
		104
		105	S.foo.self.self.x = 789;
		106
		107	try std.testing.expect(S.foo.x == 789);
		108	try std.testing.expect(S.foo.self.x == 789);
		109	try std.testing.expect(S.foo.self == &S.foo);
		110	}
		111
		112	test "global const can be indirectly self-referential" {
		113	const S = struct {
		114	other: *const @This(),
		115	x: u32,
		116
		117	const foo: @This() = .{ .other = &bar, .x = 123 };
		118	const bar: @This() = .{ .other = &foo, .x = 456 };
		119	};
		120
		121	try std.testing.expect(S.foo.x == 123);
		122	try std.testing.expect(S.foo.other.x == 456);
		123	try std.testing.expect(S.foo.other.other.x == 123);
		124	try std.testing.expect(S.foo.other.other.other.x == 456);
		125	try std.testing.expect(S.foo.other == &S.bar);
		126	try std.testing.expect(S.foo.other.other == &S.foo);
		127
		128	try std.testing.expect(S.bar.x == 456);
		129	try std.testing.expect(S.bar.other.x == 123);
		130	try std.testing.expect(S.bar.other.other.x == 456);
		131	try std.testing.expect(S.bar.other.other.other.x == 123);
		132	try std.testing.expect(S.bar.other == &S.foo);
		133	try std.testing.expect(S.bar.other.other == &S.bar);
		134	}
		135
		136	test "global var can be indirectly self-referential" {
		137	const S = struct {
		138	other: *@This(),
		139	x: u32,
		140
		141	var foo: @This() = .{ .other = &bar, .x = undefined };
		142	var bar: @This() = .{ .other = &foo, .x = undefined };
		143	};
		144
		145	S.foo.other.x = 123; // bar.x
		146	S.foo.other.other.x = 456; // foo.x
		147
		148	try std.testing.expect(S.foo.x == 456);
		149	try std.testing.expect(S.foo.other.x == 123);
		150	try std.testing.expect(S.foo.other.other.x == 456);
		151	try std.testing.expect(S.foo.other.other.other.x == 123);
		152	try std.testing.expect(S.foo.other == &S.bar);
		153	try std.testing.expect(S.foo.other.other == &S.foo);
		154
		155	S.bar.other.x = 111; // foo.x
		156	S.bar.other.other.x = 222; // bar.x
		157
		158	try std.testing.expect(S.bar.x == 222);
		159	try std.testing.expect(S.bar.other.x == 111);
		160	try std.testing.expect(S.bar.other.other.x == 222);
		161	try std.testing.expect(S.bar.other.other.other.x == 111);
		162	try std.testing.expect(S.bar.other == &S.foo);
		163	try std.testing.expect(S.bar.other.other == &S.bar);
		164	}

test/cases/compile_errors/self_reference_missing_const.zig created+11

...	@@ -0,0 +1,11 @@
1	const S = struct { self: *S, x: u32 };
2	const s: S = .{ .self = &s, .x = 123 };
3
4	comptime {
5	_ = s;
6	}
7
8	// error
9	//
10	// :2:18: error: expected type 'tmp.S', found 'const tmp.S'
11	// :2:18: note: cast discards const qualifier

author	Matthew Lugg <mlugg@mlugg.co.uk> 2024-12-23 20:39:19+00:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2024-12-24 02:18:41+00:00
log	3afda4322c34dedc2319701fdfac3505c8d311e9
tree	467873c408750cb4223f3ccf31775e42ec9fbd5c
parent	40aafcd6a85d3c517f445f17149c17523c832420
signature	Commit is signed but in an unrecognized format.

...	@@ -2906,6 +2906,7 @@ const Header = extern struct {	...	@@ -2906,6 +2906,7 @@ const Header = extern struct {
2906	file_deps_len: u32,	2906	file_deps_len: u32,
2907	src_hash_deps_len: u32,	2907	src_hash_deps_len: u32,
2908	nav_val_deps_len: u32,	2908	nav_val_deps_len: u32,
		2909	nav_ty_deps_len: u32,
2909	namespace_deps_len: u32,	2910	namespace_deps_len: u32,
2910	namespace_name_deps_len: u32,	2911	namespace_name_deps_len: u32,
2911	first_dependency_len: u32,	2912	first_dependency_len: u32,
...	@@ -2949,6 +2950,7 @@ pub fn saveState(comp: *Compilation) !void {	...	@@ -2949,6 +2950,7 @@ pub fn saveState(comp: *Compilation) !void {
2949	.file_deps_len = @intCast(ip.file_deps.count()),	2950	.file_deps_len = @intCast(ip.file_deps.count()),
2950	.src_hash_deps_len = @intCast(ip.src_hash_deps.count()),	2951	.src_hash_deps_len = @intCast(ip.src_hash_deps.count()),
2951	.nav_val_deps_len = @intCast(ip.nav_val_deps.count()),	2952	.nav_val_deps_len = @intCast(ip.nav_val_deps.count()),
		2953	.nav_ty_deps_len = @intCast(ip.nav_ty_deps.count()),
2952	.namespace_deps_len = @intCast(ip.namespace_deps.count()),	2954	.namespace_deps_len = @intCast(ip.namespace_deps.count()),
2953	.namespace_name_deps_len = @intCast(ip.namespace_name_deps.count()),	2955	.namespace_name_deps_len = @intCast(ip.namespace_name_deps.count()),
2954	.first_dependency_len = @intCast(ip.first_dependency.count()),	2956	.first_dependency_len = @intCast(ip.first_dependency.count()),
...	@@ -2979,6 +2981,8 @@ pub fn saveState(comp: *Compilation) !void {	...	@@ -2979,6 +2981,8 @@ pub fn saveState(comp: *Compilation) !void {
2979	addBuf(&bufs, mem.sliceAsBytes(ip.src_hash_deps.values()));	2981	addBuf(&bufs, mem.sliceAsBytes(ip.src_hash_deps.values()));
2980	addBuf(&bufs, mem.sliceAsBytes(ip.nav_val_deps.keys()));	2982	addBuf(&bufs, mem.sliceAsBytes(ip.nav_val_deps.keys()));
2981	addBuf(&bufs, mem.sliceAsBytes(ip.nav_val_deps.values()));	2983	addBuf(&bufs, mem.sliceAsBytes(ip.nav_val_deps.values()));
		2984	addBuf(&bufs, mem.sliceAsBytes(ip.nav_ty_deps.keys()));
		2985	addBuf(&bufs, mem.sliceAsBytes(ip.nav_ty_deps.values()));
2982	addBuf(&bufs, mem.sliceAsBytes(ip.namespace_deps.keys()));	2986	addBuf(&bufs, mem.sliceAsBytes(ip.namespace_deps.keys()));
2983	addBuf(&bufs, mem.sliceAsBytes(ip.namespace_deps.values()));	2987	addBuf(&bufs, mem.sliceAsBytes(ip.namespace_deps.values()));
2984	addBuf(&bufs, mem.sliceAsBytes(ip.namespace_name_deps.keys()));	2988	addBuf(&bufs, mem.sliceAsBytes(ip.namespace_name_deps.keys()));
...	@@ -3145,7 +3149,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {	...	@@ -3145,7 +3149,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {
3145		3149
3146	const file_index = switch (anal_unit.unwrap()) {	3150	const file_index = switch (anal_unit.unwrap()) {
3147	.@"comptime" => \|cu\| ip.getComptimeUnit(cu).zir_index.resolveFile(ip),	3151	.@"comptime" => \|cu\| ip.getComptimeUnit(cu).zir_index.resolveFile(ip),
3148	.nav_val => \|nav\| ip.getNav(nav).analysis.?.zir_index.resolveFile(ip),	3152	.nav_val, .nav_ty => \|nav\| ip.getNav(nav).analysis.?.zir_index.resolveFile(ip),
3149	.type => \|ty\| Type.fromInterned(ty).typeDeclInst(zcu).?.resolveFile(ip),	3153	.type => \|ty\| Type.fromInterned(ty).typeDeclInst(zcu).?.resolveFile(ip),
3150	.func => \|ip_index\| zcu.funcInfo(ip_index).zir_body_inst.resolveFile(ip),	3154	.func => \|ip_index\| zcu.funcInfo(ip_index).zir_body_inst.resolveFile(ip),
3151	};	3155	};
...	@@ -3380,7 +3384,7 @@ pub fn addModuleErrorMsg(	...	@@ -3380,7 +3384,7 @@ pub fn addModuleErrorMsg(
3380	defer gpa.free(rt_file_path);	3384	defer gpa.free(rt_file_path);
3381	const name = switch (ref.referencer.unwrap()) {	3385	const name = switch (ref.referencer.unwrap()) {
3382	.@"comptime" => "comptime",	3386	.@"comptime" => "comptime",
3383	.nav_val => \|nav\| ip.getNav(nav).name.toSlice(ip),	3387	.nav_val, .nav_ty => \|nav\| ip.getNav(nav).name.toSlice(ip),
3384	.type => \|ty\| Type.fromInterned(ty).containerTypeName(ip).toSlice(ip),	3388	.type => \|ty\| Type.fromInterned(ty).containerTypeName(ip).toSlice(ip),
3385	.func => \|f\| ip.getNav(zcu.funcInfo(f).owner_nav).name.toSlice(ip),	3389	.func => \|f\| ip.getNav(zcu.funcInfo(f).owner_nav).name.toSlice(ip),
3386	};	3390	};
...	@@ -3647,6 +3651,7 @@ fn performAllTheWorkInner(	...	@@ -3647,6 +3651,7 @@ fn performAllTheWorkInner(
3647	try comp.queueJob(switch (outdated.unwrap()) {	3651	try comp.queueJob(switch (outdated.unwrap()) {
3648	.func => \|f\| .{ .analyze_func = f },	3652	.func => \|f\| .{ .analyze_func = f },
3649	.@"comptime",	3653	.@"comptime",
		3654	.nav_ty,
3650	.nav_val,	3655	.nav_val,
3651	.type,	3656	.type,
3652	=> .{ .analyze_comptime_unit = outdated },	3657	=> .{ .analyze_comptime_unit = outdated },
...	@@ -3679,7 +3684,7 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre	...	@@ -3679,7 +3684,7 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre
3679	return;	3684	return;
3680	}	3685	}
3681	}	3686	}
3682	assert(nav.status == .resolved);	3687	assert(nav.status == .fully_resolved);
3683	comp.dispatchCodegenTask(tid, .{ .codegen_nav = nav_index });	3688	comp.dispatchCodegenTask(tid, .{ .codegen_nav = nav_index });
3684	},	3689	},
3685	.codegen_func => \|func\| {	3690	.codegen_func => \|func\| {
...	@@ -3709,6 +3714,7 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre	...	@@ -3709,6 +3714,7 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre
3709		3714
3710	const maybe_err: Zcu.SemaError!void = switch (unit.unwrap()) {	3715	const maybe_err: Zcu.SemaError!void = switch (unit.unwrap()) {
3711	.@"comptime" => \|cu\| pt.ensureComptimeUnitUpToDate(cu),	3716	.@"comptime" => \|cu\| pt.ensureComptimeUnitUpToDate(cu),
		3717	.nav_ty => \|nav\| pt.ensureNavTypeUpToDate(nav),
3712	.nav_val => \|nav\| pt.ensureNavValUpToDate(nav),	3718	.nav_val => \|nav\| pt.ensureNavValUpToDate(nav),
3713	.type => \|ty\| if (pt.ensureTypeUpToDate(ty)) \|_\| {} else \|err\| err,	3719	.type => \|ty\| if (pt.ensureTypeUpToDate(ty)) \|_\| {} else \|err\| err,
3714	.func => unreachable,	3720	.func => unreachable,
...	@@ -3734,7 +3740,7 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre	...	@@ -3734,7 +3740,7 @@ fn processOneJob(tid: usize, comp: *Compilation, job: Job, prog_node: std.Progre
3734	// Tests are always emitted in test binaries. The decl_refs are created by	3740	// Tests are always emitted in test binaries. The decl_refs are created by
3735	// Zcu.populateTestFunctions, but this will not queue body analysis, so do	3741	// Zcu.populateTestFunctions, but this will not queue body analysis, so do
3736	// that now.	3742	// that now.
3737	try pt.zcu.ensureFuncBodyAnalysisQueued(ip.getNav(nav).status.resolved.val);	3743	try pt.zcu.ensureFuncBodyAnalysisQueued(ip.getNav(nav).status.fully_resolved.val);
3738	}	3744	}
3739	},	3745	},
3740	.resolve_type_fully => \|ty\| {	3746	.resolve_type_fully => \|ty\| {

...	@@ -2281,7 +2281,7 @@ pub fn initWipNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool.Nav.In	...	@@ -2281,7 +2281,7 @@ pub fn initWipNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool.Nav.In
2281	const nav_ty = nav_val.typeOf(zcu);	2281	const nav_ty = nav_val.typeOf(zcu);
2282	const nav_ty_reloc_index = try wip_nav.refForward();	2282	const nav_ty_reloc_index = try wip_nav.refForward();
2283	try wip_nav.infoExprloc(.{ .addr = .{ .sym = sym_index } });	2283	try wip_nav.infoExprloc(.{ .addr = .{ .sym = sym_index } });
2284	try uleb128(diw, nav.status.resolved.alignment.toByteUnits() orelse	2284	try uleb128(diw, nav.status.fully_resolved.alignment.toByteUnits() orelse
2285	nav_ty.abiAlignment(zcu).toByteUnits().?);	2285	nav_ty.abiAlignment(zcu).toByteUnits().?);
2286	try diw.writeByte(@intFromBool(false));	2286	try diw.writeByte(@intFromBool(false));
2287	wip_nav.finishForward(nav_ty_reloc_index);	2287	wip_nav.finishForward(nav_ty_reloc_index);
...	@@ -2313,7 +2313,7 @@ pub fn initWipNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool.Nav.In	...	@@ -2313,7 +2313,7 @@ pub fn initWipNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool.Nav.In
2313	try wip_nav.refType(ty);	2313	try wip_nav.refType(ty);
2314	const addr: Loc = .{ .addr = .{ .sym = sym_index } };	2314	const addr: Loc = .{ .addr = .{ .sym = sym_index } };
2315	try wip_nav.infoExprloc(if (variable.is_threadlocal) .{ .form_tls_address = &addr } else addr);	2315	try wip_nav.infoExprloc(if (variable.is_threadlocal) .{ .form_tls_address = &addr } else addr);
2316	try uleb128(diw, nav.status.resolved.alignment.toByteUnits() orelse	2316	try uleb128(diw, nav.status.fully_resolved.alignment.toByteUnits() orelse
2317	ty.abiAlignment(zcu).toByteUnits().?);	2317	ty.abiAlignment(zcu).toByteUnits().?);
2318	try diw.writeByte(@intFromBool(false));	2318	try diw.writeByte(@intFromBool(false));
2319	},	2319	},
...	@@ -2388,7 +2388,7 @@ pub fn initWipNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool.Nav.In	...	@@ -2388,7 +2388,7 @@ pub fn initWipNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool.Nav.In
2388	wip_nav.func_high_pc = @intCast(wip_nav.debug_info.items.len);	2388	wip_nav.func_high_pc = @intCast(wip_nav.debug_info.items.len);
2389	try diw.writeInt(u32, 0, dwarf.endian);	2389	try diw.writeInt(u32, 0, dwarf.endian);
2390	const target = file.mod.resolved_target.result;	2390	const target = file.mod.resolved_target.result;
2391	try uleb128(diw, switch (nav.status.resolved.alignment) {	2391	try uleb128(diw, switch (nav.status.fully_resolved.alignment) {
2392	.none => target_info.defaultFunctionAlignment(target),	2392	.none => target_info.defaultFunctionAlignment(target),
2393	else => \|a\| a.maxStrict(target_info.minFunctionAlignment(target)),	2393	else => \|a\| a.maxStrict(target_info.minFunctionAlignment(target)),
2394	}.toByteUnits().?);	2394	}.toByteUnits().?);
...	@@ -2952,7 +2952,7 @@ pub fn updateComptimeNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool	...	@@ -2952,7 +2952,7 @@ pub fn updateComptimeNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool
2952	const nav_ty = nav_val.typeOf(zcu);	2952	const nav_ty = nav_val.typeOf(zcu);
2953	try wip_nav.refType(nav_ty);	2953	try wip_nav.refType(nav_ty);
2954	try wip_nav.blockValue(nav_src_loc, nav_val);	2954	try wip_nav.blockValue(nav_src_loc, nav_val);
2955	try uleb128(diw, nav.status.resolved.alignment.toByteUnits() orelse	2955	try uleb128(diw, nav.status.fully_resolved.alignment.toByteUnits() orelse
2956	nav_ty.abiAlignment(zcu).toByteUnits().?);	2956	nav_ty.abiAlignment(zcu).toByteUnits().?);
2957	try diw.writeByte(@intFromBool(false));	2957	try diw.writeByte(@intFromBool(false));
2958	},	2958	},
...	@@ -2977,7 +2977,7 @@ pub fn updateComptimeNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool	...	@@ -2977,7 +2977,7 @@ pub fn updateComptimeNav(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPool
2977	try wip_nav.strp(nav.name.toSlice(ip));	2977	try wip_nav.strp(nav.name.toSlice(ip));
2978	try wip_nav.strp(nav.fqn.toSlice(ip));	2978	try wip_nav.strp(nav.fqn.toSlice(ip));
2979	const nav_ty_reloc_index = try wip_nav.refForward();	2979	const nav_ty_reloc_index = try wip_nav.refForward();
2980	try uleb128(diw, nav.status.resolved.alignment.toByteUnits() orelse	2980	try uleb128(diw, nav.status.fully_resolved.alignment.toByteUnits() orelse
2981	nav_ty.abiAlignment(zcu).toByteUnits().?);	2981	nav_ty.abiAlignment(zcu).toByteUnits().?);
2982	try diw.writeByte(@intFromBool(false));	2982	try diw.writeByte(@intFromBool(false));
2983	if (has_runtime_bits) try wip_nav.blockValue(nav_src_loc, nav_val);	2983	if (has_runtime_bits) try wip_nav.blockValue(nav_src_loc, nav_val);

...	@@ -1021,7 +1021,7 @@ pub fn seeNav(self: *Plan9, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index)	...	@@ -1021,7 +1021,7 @@ pub fn seeNav(self: *Plan9, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index)
1021	const atom_idx = gop.value_ptr.index;	1021	const atom_idx = gop.value_ptr.index;
1022	// handle externs here because they might not get updateDecl called on them	1022	// handle externs here because they might not get updateDecl called on them
1023	const nav = ip.getNav(nav_index);	1023	const nav = ip.getNav(nav_index);
1024	if (ip.indexToKey(nav.status.resolved.val) == .@"extern") {	1024	if (nav.getExtern(ip) != null) {
1025	// this is a "phantom atom" - it is never actually written to disk, just convenient for us to store stuff about externs	1025	// this is a "phantom atom" - it is never actually written to disk, just convenient for us to store stuff about externs
1026	if (nav.name.eqlSlice("etext", ip)) {	1026	if (nav.name.eqlSlice("etext", ip)) {
1027	self.etext_edata_end_atom_indices[0] = atom_idx;	1027	self.etext_edata_end_atom_indices[0] = atom_idx;
...	@@ -1370,7 +1370,7 @@ pub fn getNavVAddr(	...	@@ -1370,7 +1370,7 @@ pub fn getNavVAddr(
1370	const ip = &pt.zcu.intern_pool;	1370	const ip = &pt.zcu.intern_pool;
1371	const nav = ip.getNav(nav_index);	1371	const nav = ip.getNav(nav_index);
1372	log.debug("getDeclVAddr for {}", .{nav.name.fmt(ip)});	1372	log.debug("getDeclVAddr for {}", .{nav.name.fmt(ip)});
1373	if (ip.indexToKey(nav.status.resolved.val) == .@"extern") {	1373	if (nav.getExtern(ip) != null) {
1374	if (nav.name.eqlSlice("etext", ip)) {	1374	if (nav.name.eqlSlice("etext", ip)) {
1375	try self.addReloc(reloc_info.parent.atom_index, .{	1375	try self.addReloc(reloc_info.parent.atom_index, .{
1376	.target = undefined,	1376	.target = undefined,

compiler: analyze type and value of global declaration separately