Commit 54e48f7b7dec96c8cdd1a0a0491554b118767817 | zig

lib/std/zig/AstGen.zig+57-46

 @@ -366,7 +366,6 @@ const ResultInfo = struct {
 };
 const coerced_align_ri: ResultInfo = .{ .rl = .{ .coerced_ty = .u29_type } };
-const coerced_addrspace_ri: ResultInfo = .{ .rl = .{ .coerced_ty = .address_space_type } };
 const coerced_linksection_ri: ResultInfo = .{ .rl = .{ .coerced_ty = .slice_const_u8_type } };
 const coerced_type_ri: ResultInfo = .{ .rl = .{ .coerced_ty = .type_type } };
 const coerced_bool_ri: ResultInfo = .{ .rl = .{ .coerced_ty = .bool_type } };
 @@ -1387,7 +1386,7 @@ fn fnProtoExpr(
         try expr(
             &block_scope,
             scope,
-            .{ .rl = .{ .coerced_ty = .calling_convention_type } },
+            .{ .rl = .{ .coerced_ty = try block_scope.addBuiltinValue(fn_proto.ast.callconv_expr, .calling_convention) } },
             fn_proto.ast.callconv_expr,
         )
     else
 @@ -3804,7 +3803,8 @@ fn ptrType(
         gz.astgen.source_line = source_line;
         gz.astgen.source_column = source_column;
-        addrspace_ref = try expr(gz, scope, coerced_addrspace_ri, ptr_info.ast.addrspace_node);
+        const addrspace_ty = try gz.addBuiltinValue(ptr_info.ast.addrspace_node, .address_space);
+        addrspace_ref = try expr(gz, scope, .{ .rl = .{ .coerced_ty = addrspace_ty } }, ptr_info.ast.addrspace_node);
         trailing_count += 1;
     }
     if (ptr_info.ast.align_node != 0) {
 @@ -4202,7 +4202,8 @@ fn fnDecl(
     var addrspace_gz = decl_gz.makeSubBlock(params_scope);
     defer addrspace_gz.unstack();
     const addrspace_ref: Zir.Inst.Ref = if (fn_proto.ast.addrspace_expr == 0) .none else inst: {
-        const inst = try expr(&decl_gz, params_scope, coerced_addrspace_ri, fn_proto.ast.addrspace_expr);
+        const addrspace_ty = try decl_gz.addBuiltinValue(fn_proto.ast.addrspace_expr, .address_space);
+        const inst = try expr(&decl_gz, params_scope, .{ .rl = .{ .coerced_ty = addrspace_ty } }, fn_proto.ast.addrspace_expr);
         if (addrspace_gz.instructionsSlice().len == 0) {
             // In this case we will send a len=0 body which can be encoded more efficiently.
             break :inst inst;
 @@ -4235,9 +4236,9 @@ fn fnDecl(
                 );
             }
             const inst = try expr(
-                &decl_gz,
+                &cc_gz,
                 params_scope,
-                .{ .rl = .{ .coerced_ty = .calling_convention_type } },
+                .{ .rl = .{ .coerced_ty = try cc_gz.addBuiltinValue(fn_proto.ast.callconv_expr, .calling_convention) } },
                 fn_proto.ast.callconv_expr,
             );
             if (cc_gz.instructionsSlice().len == 0) {
 @@ -4247,10 +4248,13 @@ fn fnDecl(
             _ = try cc_gz.addBreak(.break_inline, @enumFromInt(0), inst);
             break :blk inst;
         } else if (is_extern) {
-            // note: https://github.com/ziglang/zig/issues/5269
+            const inst = try cc_gz.addBuiltinValue(decl_node, .calling_convention_c);
-            break :blk .calling_convention_c;
+            _ = try cc_gz.addBreak(.break_inline, @enumFromInt(0), inst);
+            break :blk inst;
         } else if (has_inline_keyword) {
-            break :blk .calling_convention_inline;
+            const inst = try cc_gz.addBuiltinValue(decl_node, .calling_convention_inline);
+            _ = try cc_gz.addBreak(.break_inline, @enumFromInt(0), inst);
+            break :blk inst;
         } else {
             break :blk .none;
         }
 @@ -4525,7 +4529,8 @@ fn globalVarDecl(
     var addrspace_gz = linksection_gz.makeSubBlock(scope);
     if (var_decl.ast.addrspace_node != 0) {
-        const addrspace_inst = try fullBodyExpr(&addrspace_gz, &addrspace_gz.base, coerced_addrspace_ri, var_decl.ast.addrspace_node);
+        const addrspace_ty = try addrspace_gz.addBuiltinValue(var_decl.ast.addrspace_node, .address_space);
+        const addrspace_inst = try fullBodyExpr(&addrspace_gz, &addrspace_gz.base, .{ .rl = .{ .coerced_ty = addrspace_ty } }, var_decl.ast.addrspace_node);
         _ = try addrspace_gz.addBreakWithSrcNode(.break_inline, decl_inst, addrspace_inst, node);
     }
 @@ -9169,6 +9174,7 @@ fn builtinCall(
         // zig fmt: on
         .@"export" => {
+            const export_options_ty = try gz.addBuiltinValue(node, .export_options);
             const node_tags = tree.nodes.items(.tag);
             const node_datas = tree.nodes.items(.data);
             // This function causes a Decl to be exported. The first parameter is not an expression,
 @@ -9192,7 +9198,7 @@ fn builtinCall(
                                 local_val.used = ident_token;
                                 _ = try gz.addPlNode(.export_value, node, Zir.Inst.ExportValue{
                                     .operand = local_val.inst,
-                                    .options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .export_options_type } }, params[1]),
+                                    .options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = export_options_ty } }, params[1]),
                                 });
                                 return rvalue(gz, ri, .void_value, node);
                             }
 @@ -9207,7 +9213,7 @@ fn builtinCall(
                                 const loaded = try gz.addUnNode(.load, local_ptr.ptr, node);
                                 _ = try gz.addPlNode(.export_value, node, Zir.Inst.ExportValue{
                                     .operand = loaded,
-                                    .options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .export_options_type } }, params[1]),
+                                    .options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = export_options_ty } }, params[1]),
                                 });
                                 return rvalue(gz, ri, .void_value, node);
                             }
 @@ -9245,7 +9251,7 @@ fn builtinCall(
                 },
                 else => return astgen.failNode(params[0], "symbol to export must identify a declaration", .{}),
             }
-            const options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .export_options_type } }, params[1]);
+            const options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = export_options_ty } }, params[1]);
             _ = try gz.addPlNode(.@"export", node, Zir.Inst.Export{
                 .namespace = namespace,
                 .decl_name = decl_name,
 @@ -9255,7 +9261,8 @@ fn builtinCall(
         },
         .@"extern" => {
             const type_inst = try typeExpr(gz, scope, params[0]);
-            const options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .extern_options_type } }, params[1]);
+            const extern_options_ty = try gz.addBuiltinValue(node, .extern_options);
+            const options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = extern_options_ty } }, params[1]);
             const result = try gz.addExtendedPayload(.builtin_extern, Zir.Inst.BinNode{
                 .node = gz.nodeIndexToRelative(node),
                 .lhs = type_inst,
 @@ -9264,7 +9271,8 @@ fn builtinCall(
             return rvalue(gz, ri, result, node);
         },
         .fence => {
-            const order = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .atomic_order_type } }, params[0]);
+            const atomic_order_ty = try gz.addBuiltinValue(node, .atomic_order);
+            const order = try expr(gz, scope, .{ .rl = .{ .coerced_ty = atomic_order_ty } }, params[0]);
             _ = try gz.addExtendedPayload(.fence, Zir.Inst.UnNode{
                 .node = gz.nodeIndexToRelative(node),
                 .operand = order,
 @@ -9272,7 +9280,8 @@ fn builtinCall(
             return rvalue(gz, ri, .void_value, node);
         },
         .set_float_mode => {
-            const order = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .float_mode_type } }, params[0]);
+            const float_mode_ty = try gz.addBuiltinValue(node, .float_mode);
+            const order = try expr(gz, scope, .{ .rl = .{ .coerced_ty = float_mode_ty } }, params[0]);
             _ = try gz.addExtendedPayload(.set_float_mode, Zir.Inst.UnNode{
                 .node = gz.nodeIndexToRelative(node),
                 .operand = order,
 @@ -9365,7 +9374,8 @@ fn builtinCall(
         },
         .Type => {
-            const operand = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .type_info_type } }, params[0]);
+            const type_info_ty = try gz.addBuiltinValue(node, .type_info);
+            const operand = try expr(gz, scope, .{ .rl = .{ .coerced_ty = type_info_ty } }, params[0]);
             const gpa = gz.astgen.gpa;
 @@ -9502,7 +9512,8 @@ fn builtinCall(
             return rvalue(gz, ri, result, node);
         },
         .reduce => {
-            const op = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .reduce_op_type } }, params[0]);
+            const reduce_op_ty = try gz.addBuiltinValue(node, .reduce_op);
+            const op = try expr(gz, scope, .{ .rl = .{ .coerced_ty = reduce_op_ty } }, params[0]);
             const scalar = try expr(gz, scope, .{ .rl = .none }, params[1]);
             const result = try gz.addPlNode(.reduce, node, Zir.Inst.Bin{
                 .lhs = op,
 @@ -9517,34 +9528,38 @@ fn builtinCall(
         .shl_with_overflow => return overflowArithmetic(gz, scope, ri, node, params, .shl_with_overflow),
         .atomic_load => {
+            const atomic_order_type = try gz.addBuiltinValue(node, .atomic_order);
             const result = try gz.addPlNode(.atomic_load, node, Zir.Inst.AtomicLoad{
                 // zig fmt: off
-                .elem_type = try typeExpr(gz, scope,                                                   params[0]),
+                .elem_type = try typeExpr(gz, scope,                                                  params[0]),
-                .ptr       = try expr    (gz, scope, .{ .rl = .none },                                 params[1]),
+                .ptr       = try expr    (gz, scope, .{ .rl = .none },                                params[1]),
-                .ordering  = try expr    (gz, scope, .{ .rl = .{ .coerced_ty = .atomic_order_type } }, params[2]),
+                .ordering  = try expr    (gz, scope, .{ .rl = .{ .coerced_ty = atomic_order_type } }, params[2]),
                 // zig fmt: on
             });
             return rvalue(gz, ri, result, node);
         },
         .atomic_rmw => {
+            const atomic_order_type = try gz.addBuiltinValue(node, .atomic_order);
+            const atomic_rmw_op_type = try gz.addBuiltinValue(node, .atomic_rmw_op);
             const int_type = try typeExpr(gz, scope, params[0]);
             const result = try gz.addPlNode(.atomic_rmw, node, Zir.Inst.AtomicRmw{
                 // zig fmt: off
-                .ptr       = try expr(gz, scope, .{ .rl = .none },                                  params[1]),
+                .ptr       = try expr(gz, scope, .{ .rl = .none },                                 params[1]),
-                .operation = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .atomic_rmw_op_type } }, params[2]),
+                .operation = try expr(gz, scope, .{ .rl = .{ .coerced_ty = atomic_rmw_op_type } }, params[2]),
-                .operand   = try expr(gz, scope, .{ .rl = .{ .ty = int_type } },                    params[3]),
+                .operand   = try expr(gz, scope, .{ .rl = .{ .ty = int_type } },                   params[3]),
-                .ordering  = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .atomic_order_type } },  params[4]),
+                .ordering  = try expr(gz, scope, .{ .rl = .{ .coerced_ty = atomic_order_type } },  params[4]),
                 // zig fmt: on
             });
             return rvalue(gz, ri, result, node);
         },
         .atomic_store => {
+            const atomic_order_type = try gz.addBuiltinValue(node, .atomic_order);
             const int_type = try typeExpr(gz, scope, params[0]);
             _ = try gz.addPlNode(.atomic_store, node, Zir.Inst.AtomicStore{
                 // zig fmt: off
-                .ptr      = try expr(gz, scope, .{ .rl = .none },                                 params[1]),
+                .ptr      = try expr(gz, scope, .{ .rl = .none },                                params[1]),
-                .operand  = try expr(gz, scope, .{ .rl = .{ .ty = int_type } },                   params[2]),
+                .operand  = try expr(gz, scope, .{ .rl = .{ .ty = int_type } },                  params[2]),
-                .ordering = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .atomic_order_type } }, params[3]),
+                .ordering = try expr(gz, scope, .{ .rl = .{ .coerced_ty = atomic_order_type } }, params[3]),
                 // zig fmt: on
             });
             return rvalue(gz, ri, .void_value, node);
 @@ -9562,7 +9577,8 @@ fn builtinCall(
             return rvalue(gz, ri, result, node);
         },
         .call => {
-            const modifier = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .call_modifier_type } }, params[0]);
+            const call_modifier_ty = try gz.addBuiltinValue(node, .call_modifier);
+            const modifier = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = call_modifier_ty } }, params[0]);
             const callee = try expr(gz, scope, .{ .rl = .none }, params[1]);
             const args = try expr(gz, scope, .{ .rl = .none }, params[2]);
             const result = try gz.addPlNode(.builtin_call, node, Zir.Inst.BuiltinCall{
 @@ -9641,8 +9657,9 @@ fn builtinCall(
             return rvalue(gz, ri, result, node);
         },
         .prefetch => {
+            const prefetch_options_ty = try gz.addBuiltinValue(node, .prefetch_options);
             const ptr = try expr(gz, scope, .{ .rl = .none }, params[0]);
-            const options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .prefetch_options_type } }, params[1]);
+            const options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = prefetch_options_ty } }, params[1]);
             _ = try gz.addExtendedPayload(.prefetch, Zir.Inst.BinNode{
                 .node = gz.nodeIndexToRelative(node),
                 .lhs = ptr,
 @@ -9812,14 +9829,15 @@ fn cmpxchg(
     small: u16,
 ) InnerError!Zir.Inst.Ref {
     const int_type = try typeExpr(gz, scope, params[0]);
+    const atomic_order_type = try gz.addBuiltinValue(node, .atomic_order);
     const result = try gz.addExtendedPayloadSmall(.cmpxchg, small, Zir.Inst.Cmpxchg{
         // zig fmt: off
         .node           = gz.nodeIndexToRelative(node),
-        .ptr            = try expr(gz, scope, .{ .rl = .none },                                 params[1]),
+        .ptr            = try expr(gz, scope, .{ .rl = .none },                                params[1]),
-        .expected_value = try expr(gz, scope, .{ .rl = .{ .ty = int_type } },                   params[2]),
+        .expected_value = try expr(gz, scope, .{ .rl = .{ .ty = int_type } },                  params[2]),
-        .new_value      = try expr(gz, scope, .{ .rl = .{ .coerced_ty = int_type } },           params[3]),
+        .new_value      = try expr(gz, scope, .{ .rl = .{ .coerced_ty = int_type } },          params[3]),
-        .success_order  = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .atomic_order_type } }, params[4]),
+        .success_order  = try expr(gz, scope, .{ .rl = .{ .coerced_ty = atomic_order_type } }, params[4]),
-        .failure_order  = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .atomic_order_type } }, params[5]),
+        .failure_order  = try expr(gz, scope, .{ .rl = .{ .coerced_ty = atomic_order_type } }, params[5]),
         // zig fmt: on
     });
     return rvalue(gz, ri, result, node);
 @@ -11106,17 +11124,6 @@ fn rvalueInner(
                 as_ty | @intFromEnum(Zir.Inst.Ref.null_type),
                 as_ty | @intFromEnum(Zir.Inst.Ref.undefined_type),
                 as_ty | @intFromEnum(Zir.Inst.Ref.enum_literal_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.atomic_order_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.atomic_rmw_op_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.calling_convention_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.address_space_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.float_mode_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.reduce_op_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.call_modifier_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.prefetch_options_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.export_options_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.extern_options_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.type_info_type),
                 as_ty | @intFromEnum(Zir.Inst.Ref.manyptr_u8_type),
                 as_ty | @intFromEnum(Zir.Inst.Ref.manyptr_const_u8_type),
                 as_ty | @intFromEnum(Zir.Inst.Ref.manyptr_const_u8_sentinel_0_type),
 @@ -12572,6 +12579,10 @@ const GenZir = struct {
         return new_index;
     }
+    fn addBuiltinValue(gz: *GenZir, src_node: Ast.Node.Index, val: Zir.Inst.BuiltinValue) !Zir.Inst.Ref {
+        return addExtendedNodeSmall(gz, .builtin_value, src_node, @intFromEnum(val));
+    }
     fn addExtendedPayload(gz: *GenZir, opcode: Zir.Inst.Extended, extra: anytype) !Zir.Inst.Ref {
         return addExtendedPayloadSmall(gz, opcode, undefined, extra);
     }

lib/std/zig/Zir.zig+24-14

 @@ -2055,6 +2055,10 @@ pub const Inst = struct {
         /// Guaranteed to not have the `ptr_cast` flag.
         /// Uses the `pl_node` union field with payload `FieldParentPtr`.
         field_parent_ptr,
+        /// Get a type or value from `std.builtin`.
+        /// `operand` is `src_node: i32`.
+        /// `small` is an `Inst.BuiltinValue`.
+        builtin_value,
         pub const InstData = struct {
             opcode: Extended,
 @@ -2071,7 +2075,7 @@ pub const Inst = struct {
         ref_start_index = static_len,
         _,
-        pub const static_len = 84;
+        pub const static_len = 71;
         pub fn toRef(i: Index) Inst.Ref {
             return @enumFromInt(@intFromEnum(Index.ref_start_index) + @intFromEnum(i));
 @@ -2148,17 +2152,6 @@ pub const Inst = struct {
         null_type,
         undefined_type,
         enum_literal_type,
-        atomic_order_type,
-        atomic_rmw_op_type,
-        calling_convention_type,
-        address_space_type,
-        float_mode_type,
-        reduce_op_type,
-        call_modifier_type,
-        prefetch_options_type,
-        export_options_type,
-        extern_options_type,
-        type_info_type,
         manyptr_u8_type,
         manyptr_const_u8_type,
         manyptr_const_u8_sentinel_0_type,
 @@ -2179,8 +2172,6 @@ pub const Inst = struct {
         one_u8,
         four_u8,
         negative_one,
-        calling_convention_c,
-        calling_convention_inline,
         void_value,
         unreachable_value,
         null_value,
 @@ -3146,6 +3137,24 @@ pub const Inst = struct {
         }
     };
+    pub const BuiltinValue = enum(u16) {
+        // Types
+        atomic_order,
+        atomic_rmw_op,
+        calling_convention,
+        address_space,
+        float_mode,
+        reduce_op,
+        call_modifier,
+        prefetch_options,
+        export_options,
+        extern_options,
+        type_info,
+        // Values
+        calling_convention_c,
+        calling_convention_inline,
+    };
     /// Trailing:
     /// 0. tag_type: Ref, // if has_tag_type
     /// 1. captures_len: u32, // if has_captures_len
 @@ -3977,6 +3986,7 @@ fn findDeclsInner(
                 .restore_err_ret_index,
                 .closure_get,
                 .field_parent_ptr,
+                .builtin_value,
                 => return,
                 // `@TypeOf` has a body.

src/Air.zig-13

...	@@ -938,17 +938,6 @@ pub const Inst = struct {	...	@@ -938,17 +938,6 @@ pub const Inst = struct {
938	null_type = @intFromEnum(InternPool.Index.null_type),	938	null_type = @intFromEnum(InternPool.Index.null_type),
939	undefined_type = @intFromEnum(InternPool.Index.undefined_type),	939	undefined_type = @intFromEnum(InternPool.Index.undefined_type),
940	enum_literal_type = @intFromEnum(InternPool.Index.enum_literal_type),	940	enum_literal_type = @intFromEnum(InternPool.Index.enum_literal_type),
941	atomic_order_type = @intFromEnum(InternPool.Index.atomic_order_type),
942	atomic_rmw_op_type = @intFromEnum(InternPool.Index.atomic_rmw_op_type),
943	calling_convention_type = @intFromEnum(InternPool.Index.calling_convention_type),
944	address_space_type = @intFromEnum(InternPool.Index.address_space_type),
945	float_mode_type = @intFromEnum(InternPool.Index.float_mode_type),
946	reduce_op_type = @intFromEnum(InternPool.Index.reduce_op_type),
947	call_modifier_type = @intFromEnum(InternPool.Index.call_modifier_type),
948	prefetch_options_type = @intFromEnum(InternPool.Index.prefetch_options_type),
949	export_options_type = @intFromEnum(InternPool.Index.export_options_type),
950	extern_options_type = @intFromEnum(InternPool.Index.extern_options_type),
951	type_info_type = @intFromEnum(InternPool.Index.type_info_type),
952	manyptr_u8_type = @intFromEnum(InternPool.Index.manyptr_u8_type),	941	manyptr_u8_type = @intFromEnum(InternPool.Index.manyptr_u8_type),
953	manyptr_const_u8_type = @intFromEnum(InternPool.Index.manyptr_const_u8_type),	942	manyptr_const_u8_type = @intFromEnum(InternPool.Index.manyptr_const_u8_type),
954	manyptr_const_u8_sentinel_0_type = @intFromEnum(InternPool.Index.manyptr_const_u8_sentinel_0_type),	943	manyptr_const_u8_sentinel_0_type = @intFromEnum(InternPool.Index.manyptr_const_u8_sentinel_0_type),
...	@@ -969,8 +958,6 @@ pub const Inst = struct {	...	@@ -969,8 +958,6 @@ pub const Inst = struct {
969	one_u8 = @intFromEnum(InternPool.Index.one_u8),	958	one_u8 = @intFromEnum(InternPool.Index.one_u8),
970	four_u8 = @intFromEnum(InternPool.Index.four_u8),	959	four_u8 = @intFromEnum(InternPool.Index.four_u8),
971	negative_one = @intFromEnum(InternPool.Index.negative_one),	960	negative_one = @intFromEnum(InternPool.Index.negative_one),
972	calling_convention_c = @intFromEnum(InternPool.Index.calling_convention_c),
973	calling_convention_inline = @intFromEnum(InternPool.Index.calling_convention_inline),
974	void_value = @intFromEnum(InternPool.Index.void_value),	961	void_value = @intFromEnum(InternPool.Index.void_value),
975	unreachable_value = @intFromEnum(InternPool.Index.unreachable_value),	962	unreachable_value = @intFromEnum(InternPool.Index.unreachable_value),
976	null_value = @intFromEnum(InternPool.Index.null_value),	963	null_value = @intFromEnum(InternPool.Index.null_value),

src/InternPool.zig+11-143

...	@@ -2160,6 +2160,14 @@ pub const Key = union(enum) {	...	@@ -2160,6 +2160,14 @@ pub const Key = union(enum) {
2160	pub fn resolvedErrorSetUnordered(func: Func, ip: *const InternPool) Index {	2160	pub fn resolvedErrorSetUnordered(func: Func, ip: *const InternPool) Index {
2161	return @atomicLoad(Index, func.resolvedErrorSetPtr(@constCast(ip)), .unordered);	2161	return @atomicLoad(Index, func.resolvedErrorSetPtr(@constCast(ip)), .unordered);
2162	}	2162	}
		2163
		2164	pub fn setResolvedErrorSet(func: Func, ip: *InternPool, ies: Index) void {
		2165	const extra_mutex = &ip.getLocal(func.tid).mutate.extra.mutex;
		2166	extra_mutex.lock();
		2167	defer extra_mutex.unlock();
		2168
		2169	@atomicStore(Index, func.resolvedErrorSetPtr(ip), ies, .release);
		2170	}
2163	};	2171	};
2164		2172
2165	pub const Int = struct {	2173	pub const Int = struct {
...	@@ -4403,17 +4411,6 @@ pub const Index = enum(u32) {	...	@@ -4403,17 +4411,6 @@ pub const Index = enum(u32) {
4403	null_type,	4411	null_type,
4404	undefined_type,	4412	undefined_type,
4405	enum_literal_type,	4413	enum_literal_type,
4406	atomic_order_type,
4407	atomic_rmw_op_type,
4408	calling_convention_type,
4409	address_space_type,
4410	float_mode_type,
4411	reduce_op_type,
4412	call_modifier_type,
4413	prefetch_options_type,
4414	export_options_type,
4415	extern_options_type,
4416	type_info_type,
4417	manyptr_u8_type,	4414	manyptr_u8_type,
4418	manyptr_const_u8_type,	4415	manyptr_const_u8_type,
4419	manyptr_const_u8_sentinel_0_type,	4416	manyptr_const_u8_sentinel_0_type,
...	@@ -4446,10 +4443,6 @@ pub const Index = enum(u32) {	...	@@ -4446,10 +4443,6 @@ pub const Index = enum(u32) {
4446	four_u8,	4443	four_u8,
4447	/// `-1` (comptime_int)	4444	/// `-1` (comptime_int)
4448	negative_one,	4445	negative_one,
4449	/// `std.builtin.CallingConvention.C`
4450	calling_convention_c,
4451	/// `std.builtin.CallingConvention.Inline`
4452	calling_convention_inline,
4453	/// `{}`	4446	/// `{}`
4454	void_value,	4447	void_value,
4455	/// `unreachable` (noreturn type)	4448	/// `unreachable` (noreturn type)
...	@@ -4829,17 +4822,6 @@ pub const static_keys = [_]Key{	...	@@ -4829,17 +4822,6 @@ pub const static_keys = [_]Key{
4829	.{ .simple_type = .null },	4822	.{ .simple_type = .null },
4830	.{ .simple_type = .undefined },	4823	.{ .simple_type = .undefined },
4831	.{ .simple_type = .enum_literal },	4824	.{ .simple_type = .enum_literal },
4832	.{ .simple_type = .atomic_order },
4833	.{ .simple_type = .atomic_rmw_op },
4834	.{ .simple_type = .calling_convention },
4835	.{ .simple_type = .address_space },
4836	.{ .simple_type = .float_mode },
4837	.{ .simple_type = .reduce_op },
4838	.{ .simple_type = .call_modifier },
4839	.{ .simple_type = .prefetch_options },
4840	.{ .simple_type = .export_options },
4841	.{ .simple_type = .extern_options },
4842	.{ .simple_type = .type_info },
4843		4825
4844	// [*]u8	4826	// [*]u8
4845	.{ .ptr_type = .{	4827	.{ .ptr_type = .{
...	@@ -4868,7 +4850,7 @@ pub const static_keys = [_]Key{	...	@@ -4868,7 +4850,7 @@ pub const static_keys = [_]Key{
4868	},	4850	},
4869	} },	4851	} },
4870		4852
4871	// comptime_int	4853	// *const comptime_int
4872	.{ .ptr_type = .{	4854	.{ .ptr_type = .{
4873	.child = .comptime_int_type,	4855	.child = .comptime_int_type,
4874	.flags = .{	4856	.flags = .{
...	@@ -4959,16 +4941,6 @@ pub const static_keys = [_]Key{	...	@@ -4959,16 +4941,6 @@ pub const static_keys = [_]Key{
4959	.ty = .comptime_int_type,	4941	.ty = .comptime_int_type,
4960	.storage = .{ .i64 = -1 },	4942	.storage = .{ .i64 = -1 },
4961	} },	4943	} },
4962	// calling_convention_c
4963	.{ .enum_tag = .{
4964	.ty = .calling_convention_type,
4965	.int = .one_u8,
4966	} },
4967	// calling_convention_inline
4968	.{ .enum_tag = .{
4969	.ty = .calling_convention_type,
4970	.int = .four_u8,
4971	} },
4972		4944
4973	.{ .simple_value = .void },	4945	.{ .simple_value = .void },
4974	.{ .simple_value = .@"unreachable" },	4946	.{ .simple_value = .@"unreachable" },
...	@@ -5682,18 +5654,6 @@ pub const SimpleType = enum(u32) {	...	@@ -5682,18 +5654,6 @@ pub const SimpleType = enum(u32) {
5682	undefined = @intFromEnum(Index.undefined_type),	5654	undefined = @intFromEnum(Index.undefined_type),
5683	enum_literal = @intFromEnum(Index.enum_literal_type),	5655	enum_literal = @intFromEnum(Index.enum_literal_type),
5684		5656
5685	atomic_order = @intFromEnum(Index.atomic_order_type),
5686	atomic_rmw_op = @intFromEnum(Index.atomic_rmw_op_type),
5687	calling_convention = @intFromEnum(Index.calling_convention_type),
5688	address_space = @intFromEnum(Index.address_space_type),
5689	float_mode = @intFromEnum(Index.float_mode_type),
5690	reduce_op = @intFromEnum(Index.reduce_op_type),
5691	call_modifier = @intFromEnum(Index.call_modifier_type),
5692	prefetch_options = @intFromEnum(Index.prefetch_options_type),
5693	export_options = @intFromEnum(Index.export_options_type),
5694	extern_options = @intFromEnum(Index.extern_options_type),
5695	type_info = @intFromEnum(Index.type_info_type),
5696
5697	adhoc_inferred_error_set = @intFromEnum(Index.adhoc_inferred_error_set_type),	5657	adhoc_inferred_error_set = @intFromEnum(Index.adhoc_inferred_error_set_type),
5698	generic_poison = @intFromEnum(Index.generic_poison_type),	5658	generic_poison = @intFromEnum(Index.generic_poison_type),
5699	};	5659	};
...	@@ -6273,18 +6233,6 @@ pub fn init(ip: *InternPool, gpa: Allocator, available_threads: usize) !void {	...	@@ -6273,18 +6233,6 @@ pub fn init(ip: *InternPool, gpa: Allocator, available_threads: usize) !void {
6273	// Sanity check.	6233	// Sanity check.
6274	assert(ip.indexToKey(.bool_true).simple_value == .true);	6234	assert(ip.indexToKey(.bool_true).simple_value == .true);
6275	assert(ip.indexToKey(.bool_false).simple_value == .false);	6235	assert(ip.indexToKey(.bool_false).simple_value == .false);
6276
6277	const cc_inline = ip.indexToKey(.calling_convention_inline).enum_tag.int;
6278	const cc_c = ip.indexToKey(.calling_convention_c).enum_tag.int;
6279
6280	assert(ip.indexToKey(cc_inline).int.storage.u64 ==
6281	@intFromEnum(std.builtin.CallingConvention.Inline));
6282
6283	assert(ip.indexToKey(cc_c).int.storage.u64 ==
6284	@intFromEnum(std.builtin.CallingConvention.C));
6285
6286	assert(ip.indexToKey(ip.typeOf(cc_inline)).int_type.bits ==
6287	@typeInfo(@typeInfo(std.builtin.CallingConvention).Enum.tag_type).Int.bits);
6288	}	6236	}
6289	}	6237	}
6290		6238
...	@@ -7100,7 +7048,7 @@ fn getOrPutKeyEnsuringAdditionalCapacity(	...	@@ -7100,7 +7048,7 @@ fn getOrPutKeyEnsuringAdditionalCapacity(
7100	const index = entry.acquire();	7048	const index = entry.acquire();
7101	if (index == .none) break;	7049	if (index == .none) break;
7102	if (entry.hash != hash) continue;	7050	if (entry.hash != hash) continue;
7103	if (ip.isRemoved(index)) continue;	7051	if (index.unwrap(ip).getTag(ip) == .removed) continue;
7104	if (ip.indexToKey(index).eql(key, ip)) return .{ .existing = index };	7052	if (ip.indexToKey(index).eql(key, ip)) return .{ .existing = index };
7105	}	7053	}
7106	shard.mutate.map.mutex.lock();	7054	shard.mutate.map.mutex.lock();
...	@@ -9735,14 +9683,6 @@ fn addMap(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, cap: usize) Al	...	@@ -9735,14 +9683,6 @@ fn addMap(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, cap: usize) Al
9735	/// Invalidates all references to this index.	9683	/// Invalidates all references to this index.
9736	pub fn remove(ip: *InternPool, tid: Zcu.PerThread.Id, index: Index) void {	9684	pub fn remove(ip: *InternPool, tid: Zcu.PerThread.Id, index: Index) void {
9737	const unwrapped_index = index.unwrap(ip);	9685	const unwrapped_index = index.unwrap(ip);
9738	if (@intFromEnum(index) < static_keys.len) {
9739	// The item being removed replaced a special index via `InternPool.resolveBuiltinType`.
9740	// Restore the original item at this index.
9741	assert(static_keys[@intFromEnum(index)] == .simple_type);
9742	const items = ip.getLocalShared(unwrapped_index.tid).items.acquire().view();
9743	@atomicStore(Tag, &items.items(.tag)[unwrapped_index.index], .simple_type, .unordered);
9744	return;
9745	}
9746		9686
9747	if (unwrapped_index.tid == tid) {	9687	if (unwrapped_index.tid == tid) {
9748	const items_len = &ip.getLocal(unwrapped_index.tid).mutate.items.len;	9688	const items_len = &ip.getLocal(unwrapped_index.tid).mutate.items.len;
...	@@ -10382,17 +10322,7 @@ pub fn isIntegerType(ip: *const InternPool, ty: Index) bool {	...	@@ -10382,17 +10322,7 @@ pub fn isIntegerType(ip: *const InternPool, ty: Index) bool {
10382		10322
10383	/// does not include .enum_literal_type	10323	/// does not include .enum_literal_type
10384	pub fn isEnumType(ip: *const InternPool, ty: Index) bool {	10324	pub fn isEnumType(ip: *const InternPool, ty: Index) bool {
10385	return switch (ty) {	10325	return ip.indexToKey(ty) == .enum_type;
10386	.atomic_order_type,
10387	.atomic_rmw_op_type,
10388	.calling_convention_type,
10389	.address_space_type,
10390	.float_mode_type,
10391	.reduce_op_type,
10392	.call_modifier_type,
10393	=> true,
10394	else => ip.indexToKey(ty) == .enum_type,
10395	};
10396	}	10326	}
10397		10327
10398	pub fn isUnion(ip: *const InternPool, ty: Index) bool {	10328	pub fn isUnion(ip: *const InternPool, ty: Index) bool {
...	@@ -11393,17 +11323,6 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index {	...	@@ -11393,17 +11323,6 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index {
11393	.null_type,	11323	.null_type,
11394	.undefined_type,	11324	.undefined_type,
11395	.enum_literal_type,	11325	.enum_literal_type,
11396	.atomic_order_type,
11397	.atomic_rmw_op_type,
11398	.calling_convention_type,
11399	.address_space_type,
11400	.float_mode_type,
11401	.reduce_op_type,
11402	.call_modifier_type,
11403	.prefetch_options_type,
11404	.export_options_type,
11405	.extern_options_type,
11406	.type_info_type,
11407	.manyptr_u8_type,	11326	.manyptr_u8_type,
11408	.manyptr_const_u8_type,	11327	.manyptr_const_u8_type,
11409	.manyptr_const_u8_sentinel_0_type,	11328	.manyptr_const_u8_sentinel_0_type,
...	@@ -11421,7 +11340,6 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index {	...	@@ -11421,7 +11340,6 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index {
11421	.zero, .one, .negative_one => .comptime_int_type,	11340	.zero, .one, .negative_one => .comptime_int_type,
11422	.zero_usize, .one_usize => .usize_type,	11341	.zero_usize, .one_usize => .usize_type,
11423	.zero_u8, .one_u8, .four_u8 => .u8_type,	11342	.zero_u8, .one_u8, .four_u8 => .u8_type,
11424	.calling_convention_c, .calling_convention_inline => .calling_convention_type,
11425	.void_value => .void_type,	11343	.void_value => .void_type,
11426	.unreachable_value => .noreturn_type,	11344	.unreachable_value => .noreturn_type,
11427	.null_value => .null_type,	11345	.null_value => .null_type,
...	@@ -11717,22 +11635,6 @@ pub fn zigTypeTagOrPoison(ip: *const InternPool, index: Index) error{GenericPois	...	@@ -11717,22 +11635,6 @@ pub fn zigTypeTagOrPoison(ip: *const InternPool, index: Index) error{GenericPois
11717	.undefined_type => .Undefined,	11635	.undefined_type => .Undefined,
11718	.enum_literal_type => .EnumLiteral,	11636	.enum_literal_type => .EnumLiteral,
11719		11637
11720	.atomic_order_type,
11721	.atomic_rmw_op_type,
11722	.calling_convention_type,
11723	.address_space_type,
11724	.float_mode_type,
11725	.reduce_op_type,
11726	.call_modifier_type,
11727	=> .Enum,
11728
11729	.prefetch_options_type,
11730	.export_options_type,
11731	.extern_options_type,
11732	=> .Struct,
11733
11734	.type_info_type => .Union,
11735
11736	.manyptr_u8_type,	11638	.manyptr_u8_type,
11737	.manyptr_const_u8_type,	11639	.manyptr_const_u8_type,
11738	.manyptr_const_u8_sentinel_0_type,	11640	.manyptr_const_u8_sentinel_0_type,
...	@@ -11757,8 +11659,6 @@ pub fn zigTypeTagOrPoison(ip: *const InternPool, index: Index) error{GenericPois	...	@@ -11757,8 +11659,6 @@ pub fn zigTypeTagOrPoison(ip: *const InternPool, index: Index) error{GenericPois
11757	.one_u8 => unreachable,	11659	.one_u8 => unreachable,
11758	.four_u8 => unreachable,	11660	.four_u8 => unreachable,
11759	.negative_one => unreachable,	11661	.negative_one => unreachable,
11760	.calling_convention_c => unreachable,
11761	.calling_convention_inline => unreachable,
11762	.void_value => unreachable,	11662	.void_value => unreachable,
11763	.unreachable_value => unreachable,	11663	.unreachable_value => unreachable,
11764	.null_value => unreachable,	11664	.null_value => unreachable,
...	@@ -12077,34 +11977,6 @@ pub fn unwrapCoercedFunc(ip: *const InternPool, index: Index) Index {	...	@@ -12077,34 +11977,6 @@ pub fn unwrapCoercedFunc(ip: *const InternPool, index: Index) Index {
12077	};	11977	};
12078	}	11978	}
12079		11979
12080	/// Having resolved a builtin type to a real struct/union/enum (which is now at `resolverd_index`),
12081	/// make `want_index` refer to this type instead. This invalidates `resolved_index`, so must be
12082	/// called only when it is guaranteed that no reference to `resolved_index` exists.
12083	pub fn resolveBuiltinType(
12084	ip: *InternPool,
12085	tid: Zcu.PerThread.Id,
12086	want_index: Index,
12087	resolved_index: Index,
12088	) void {
12089	assert(@intFromEnum(want_index) >= @intFromEnum(Index.first_type));
12090	assert(@intFromEnum(want_index) <= @intFromEnum(Index.last_type));
12091
12092	// Make sure the type isn't already resolved!
12093	assert(ip.indexToKey(want_index) == .simple_type);
12094
12095	// Make sure it's the same kind of type
12096	assert((ip.zigTypeTagOrPoison(want_index) catch unreachable) ==
12097	(ip.zigTypeTagOrPoison(resolved_index) catch unreachable));
12098
12099	// Copy the data
12100	const item = resolved_index.unwrap(ip).getItem(ip);
12101	const unwrapped_index = want_index.unwrap(ip);
12102	var items = ip.getLocalShared(unwrapped_index.tid).items.acquire().view().slice();
12103	items.items(.data)[unwrapped_index.index] = item.data;
12104	@atomicStore(Tag, &items.items(.tag)[unwrapped_index.index], item.tag, .release);
12105	ip.remove(tid, resolved_index);
12106	}
12107
12108	pub fn anonStructFieldTypes(ip: *const InternPool, i: Index) []const Index {	11980	pub fn anonStructFieldTypes(ip: *const InternPool, i: Index) []const Index {
12109	return ip.indexToKey(i).anon_struct_type.types;	11981	return ip.indexToKey(i).anon_struct_type.types;
12110	}	11982	}
...	@@ -12303,7 +12175,3 @@ pub fn getErrorValue(	...	@@ -12303,7 +12175,3 @@ pub fn getErrorValue(
12303	pub fn getErrorValueIfExists(ip: *const InternPool, name: NullTerminatedString) ?Zcu.ErrorInt {	12175	pub fn getErrorValueIfExists(ip: *const InternPool, name: NullTerminatedString) ?Zcu.ErrorInt {
12304	return @intFromEnum(ip.global_error_set.getErrorValueIfExists(name) orelse return null);	12176	return @intFromEnum(ip.global_error_set.getErrorValueIfExists(name) orelse return null);
12305	}	12177	}
12306
12307	pub fn isRemoved(ip: *const InternPool, ty: Index) bool {
12308	return ty.unwrap(ip).getTag(ip) == .removed;
12309	}

src/Sema.zig+55-41

 @@ -76,10 +76,6 @@ no_partial_func_ty: bool = false,
 /// here so the values can be dropped without any cleanup.
 unresolved_inferred_allocs: std.AutoArrayHashMapUnmanaged(Air.Inst.Index, InferredAlloc) = .{},
-/// While analyzing a type which has a special InternPool index, this is set to the index at which
-/// the struct/enum/union type created should be placed. Otherwise, it is `.none`.
-builtin_type_target_index: InternPool.Index = .none,
 /// Links every pointer derived from a base `alloc` back to that `alloc`. Used
 /// to detect comptime-known `const`s.
 /// TODO: ZIR liveness analysis would allow us to remove elements from this map.
 @@ -1327,6 +1323,7 @@ fn analyzeBodyInner(
                     },
                     .value_placeholder => unreachable, // never appears in a body
                     .field_parent_ptr => try sema.zirFieldParentPtr(block, extended),
+                    .builtin_value => try sema.zirBuiltinValue(extended),
                 };
             },
 @@ -2712,17 +2709,6 @@ fn getCaptures(sema: *Sema, block: *Block, type_src: LazySrcLoc, extra_index: us
     return captures;
 }
-/// Given an `InternPool.WipNamespaceType` or `InternPool.WipEnumType`, apply
-/// `sema.builtin_type_target_index` to it if necessary.
-fn wrapWipTy(sema: *Sema, wip_ty: anytype) @TypeOf(wip_ty) {
-    const pt = sema.pt;
-    if (sema.builtin_type_target_index == .none) return wip_ty;
-    var new = wip_ty;
-    new.index = sema.builtin_type_target_index;
-    pt.zcu.intern_pool.resolveBuiltinType(pt.tid, new.index, wip_ty.index);
-    return new;
-}
 fn zirStructDecl(
     sema: *Sema,
     block: *Block,
 @@ -2788,7 +2774,7 @@ fn zirStructDecl(
             .captures = captures,
         } },
     };
-    const wip_ty = sema.wrapWipTy(switch (try ip.getStructType(gpa, pt.tid, struct_init, false)) {
+    const wip_ty = switch (try ip.getStructType(gpa, pt.tid, struct_init, false)) {
         .existing => |ty| {
             const new_ty = try pt.ensureTypeUpToDate(ty, false);
 @@ -2801,7 +2787,7 @@ fn zirStructDecl(
             return Air.internedToRef(new_ty);
         },
         .wip => |wip| wip,
-    });
+    };
     errdefer wip_ty.cancel(ip, pt.tid);
     wip_ty.setName(ip, try sema.createTypeName(
 @@ -3017,7 +3003,7 @@ fn zirEnumDecl(
             .captures = captures,
         } },
     };
-    const wip_ty = sema.wrapWipTy(switch (try ip.getEnumType(gpa, pt.tid, enum_init, false)) {
+    const wip_ty = switch (try ip.getEnumType(gpa, pt.tid, enum_init, false)) {
         .existing => |ty| {
             const new_ty = try pt.ensureTypeUpToDate(ty, false);
 @@ -3030,7 +3016,7 @@ fn zirEnumDecl(
             return Air.internedToRef(new_ty);
         },
         .wip => |wip| wip,
-    });
+    };
     // Once this is `true`, we will not delete the decl or type even upon failure, since we
     // have finished constructing the type and are in the process of analyzing it.
 @@ -3161,7 +3147,7 @@ fn zirUnionDecl(
             .captures = captures,
         } },
     };
-    const wip_ty = sema.wrapWipTy(switch (try ip.getUnionType(gpa, pt.tid, union_init, false)) {
+    const wip_ty = switch (try ip.getUnionType(gpa, pt.tid, union_init, false)) {
         .existing => |ty| {
             const new_ty = try pt.ensureTypeUpToDate(ty, false);
 @@ -3174,7 +3160,7 @@ fn zirUnionDecl(
             return Air.internedToRef(new_ty);
         },
         .wip => |wip| wip,
-    });
+    };
     errdefer wip_ty.cancel(ip, pt.tid);
     wip_ty.setName(ip, try sema.createTypeName(
 @@ -3259,7 +3245,6 @@ fn zirOpaqueDecl(
             .captures = captures,
         } },
     };
-    // No `wrapWipTy` needed as no std.builtin types are opaque.
     const wip_ty = switch (try ip.getOpaqueType(gpa, pt.tid, opaque_init)) {
         .existing => |ty| {
             // Make sure we update the namespace if the declaration is re-analyzed, to pick
 @@ -26179,7 +26164,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         const body = sema.code.bodySlice(extra_index, body_len);
         extra_index += body.len;
-        const addrspace_ty = Type.fromInterned(.address_space_type);
+        const addrspace_ty = try pt.getBuiltinType("AddressSpace");
         const val = try sema.resolveGenericBody(block, addrspace_src, body, inst, addrspace_ty, .{
             .needed_comptime_reason = "addrspace must be comptime-known",
         });
 @@ -26190,7 +26175,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     } else if (extra.data.bits.has_addrspace_ref) blk: {
         const addrspace_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]);
         extra_index += 1;
-        const addrspace_ty = Type.fromInterned(.address_space_type);
+        const addrspace_ty = try pt.getBuiltinType("AddressSpace");
         const uncoerced_addrspace = sema.resolveInst(addrspace_ref) catch |err| switch (err) {
             error.GenericPoison => break :blk null,
             else => |e| return e,
 @@ -26255,7 +26240,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     } else if (extra.data.bits.has_cc_ref) blk: {
         const cc_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]);
         extra_index += 1;
-        const cc_ty = Type.fromInterned(.calling_convention_type);
+        const cc_ty = try pt.getBuiltinType("CallingConvention");
         const uncoerced_cc = sema.resolveInst(cc_ref) catch |err| switch (err) {
             error.GenericPoison => break :blk null,
             else => |e| return e,
 @@ -26713,6 +26698,46 @@ fn zirInComptime(
     return if (block.is_comptime) .bool_true else .bool_false;
 }
+fn zirBuiltinValue(sema: *Sema, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref {
+    const pt = sema.pt;
+    const value: Zir.Inst.BuiltinValue = @enumFromInt(extended.small);
+    const type_name = switch (value) {
+        .atomic_order => "AtomicOrder",
+        .atomic_rmw_op => "AtomicRmwOp",
+        .calling_convention => "CallingConvention",
+        .address_space => "AddressSpace",
+        .float_mode => "FloatMode",
+        .reduce_op => "ReduceOp",
+        .call_modifier => "CallModifier",
+        .prefetch_options => "PrefetchOptions",
+        .export_options => "ExportOptions",
+        .extern_options => "ExternOptions",
+        .type_info => "Type",
+        // Values are handled here.
+        .calling_convention_c => {
+            const callconv_ty = try pt.getBuiltinType("CallingConvention");
+            comptime assert(@intFromEnum(std.builtin.CallingConvention.C) == 1);
+            const val = try pt.intern(.{ .enum_tag = .{
+                .ty = callconv_ty.toIntern(),
+                .int = .one_u8,
+            } });
+            return Air.internedToRef(val);
+        },
+        .calling_convention_inline => {
+            const callconv_ty = try pt.getBuiltinType("CallingConvention");
+            comptime assert(@intFromEnum(std.builtin.CallingConvention.Inline) == 4);
+            const val = try pt.intern(.{ .enum_tag = .{
+                .ty = callconv_ty.toIntern(),
+                .int = .four_u8,
+            } });
+            return Air.internedToRef(val);
+        },
+    };
+    const ty = try pt.getBuiltinType(type_name);
+    return Air.internedToRef(ty.toIntern());
+}
 fn requireRuntimeBlock(sema: *Sema, block: *Block, src: LazySrcLoc, runtime_src: ?LazySrcLoc) !void {
     if (block.is_comptime) {
         const msg = msg: {
 @@ -32527,6 +32552,7 @@ fn analyzeIsNonErrComptimeOnly(
                 // If the error set is empty, we must return a comptime true or false.
                 // However we want to avoid unnecessarily resolving an inferred error set
                 // in case it is already non-empty.
+                try mod.maybeUnresolveIes(func_index);
                 switch (ip.funcIesResolvedUnordered(func_index)) {
                     .anyerror_type => break :blk,
                     .none => {},
 @@ -33596,6 +33622,7 @@ fn wrapErrorUnionSet(
                 .inferred_error_set_type => |func_index| ok: {
                     // We carefully do this in an order that avoids unnecessarily
                     // resolving the destination error set type.
+                    try mod.maybeUnresolveIes(func_index);
                     switch (ip.funcIesResolvedUnordered(func_index)) {
                         .anyerror_type => break :ok,
                         .none => if (.ok == try sema.coerceInMemoryAllowedErrorSets(block, dest_err_set_ty, inst_ty, inst_src, inst_src)) {
 @@ -35853,8 +35880,7 @@ fn resolveInferredErrorSet(
     try sema.declareDependency(.{ .interned = func_index }); // resolved IES
-    // TODO: during an incremental update this might not be `.none`, but the
+    try zcu.maybeUnresolveIes(func_index);
-    // function might be out-of-date!
     const resolved_ty = func.resolvedErrorSetUnordered(ip);
     if (resolved_ty != .none) return resolved_ty;
 @@ -36898,17 +36924,6 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
         .comptime_int_type,
         .comptime_float_type,
         .enum_literal_type,
-        .atomic_order_type,
-        .atomic_rmw_op_type,
-        .calling_convention_type,
-        .address_space_type,
-        .float_mode_type,
-        .reduce_op_type,
-        .call_modifier_type,
-        .prefetch_options_type,
-        .export_options_type,
-        .extern_options_type,
-        .type_info_type,
         .manyptr_u8_type,
         .manyptr_const_u8_type,
         .manyptr_const_u8_sentinel_0_type,
 @@ -36935,8 +36950,6 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
         .one_u8,
         .four_u8,
         .negative_one,
-        .calling_convention_c,
-        .calling_convention_inline,
         .void_value,
         .unreachable_value,
         .null_value,
 @@ -37290,7 +37303,8 @@ pub fn analyzeAsAddressSpace(
 ) !std.builtin.AddressSpace {
     const pt = sema.pt;
     const mod = pt.zcu;
-    const coerced = try sema.coerce(block, Type.fromInterned(.address_space_type), air_ref, src);
+    const addrspace_ty = try pt.getBuiltinType("AddressSpace");
+    const coerced = try sema.coerce(block, addrspace_ty, air_ref, src);
     const addrspace_val = try sema.resolveConstDefinedValue(block, src, coerced, .{
         .needed_comptime_reason = "address space must be comptime-known",
     });

src/Type.zig+1-129

...	@@ -316,17 +316,6 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error	...	@@ -316,17 +316,6 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error
316	=> try writer.print("@TypeOf({s})", .{@tagName(s)}),	316	=> try writer.print("@TypeOf({s})", .{@tagName(s)}),
317		317
318	.enum_literal => try writer.print("@TypeOf(.{s})", .{@tagName(s)}),	318	.enum_literal => try writer.print("@TypeOf(.{s})", .{@tagName(s)}),
319	.atomic_order => try writer.writeAll("std.builtin.AtomicOrder"),
320	.atomic_rmw_op => try writer.writeAll("std.builtin.AtomicRmwOp"),
321	.calling_convention => try writer.writeAll("std.builtin.CallingConvention"),
322	.address_space => try writer.writeAll("std.builtin.AddressSpace"),
323	.float_mode => try writer.writeAll("std.builtin.FloatMode"),
324	.reduce_op => try writer.writeAll("std.builtin.ReduceOp"),
325	.call_modifier => try writer.writeAll("std.builtin.CallModifier"),
326	.prefetch_options => try writer.writeAll("std.builtin.PrefetchOptions"),
327	.export_options => try writer.writeAll("std.builtin.ExportOptions"),
328	.extern_options => try writer.writeAll("std.builtin.ExternOptions"),
329	.type_info => try writer.writeAll("std.builtin.Type"),
330		319
331	.generic_poison => unreachable,	320	.generic_poison => unreachable,
332	},	321	},
...	@@ -544,16 +533,6 @@ pub fn hasRuntimeBitsAdvanced(	...	@@ -544,16 +533,6 @@ pub fn hasRuntimeBitsAdvanced(
544	.anyerror,	533	.anyerror,
545	.adhoc_inferred_error_set,	534	.adhoc_inferred_error_set,
546	.anyopaque,	535	.anyopaque,
547	.atomic_order,
548	.atomic_rmw_op,
549	.calling_convention,
550	.address_space,
551	.float_mode,
552	.reduce_op,
553	.call_modifier,
554	.prefetch_options,
555	.export_options,
556	.extern_options,
557	=> true,	536	=> true,
558		537
559	// These are false because they are comptime-only types.	538	// These are false because they are comptime-only types.
...	@@ -565,7 +544,6 @@ pub fn hasRuntimeBitsAdvanced(	...	@@ -565,7 +544,6 @@ pub fn hasRuntimeBitsAdvanced(
565	.null,	544	.null,
566	.undefined,	545	.undefined,
567	.enum_literal,	546	.enum_literal,
568	.type_info,
569	=> false,	547	=> false,
570		548
571	.generic_poison => unreachable,	549	.generic_poison => unreachable,
...	@@ -711,16 +689,6 @@ pub fn hasWellDefinedLayout(ty: Type, mod: *Module) bool {	...	@@ -711,16 +689,6 @@ pub fn hasWellDefinedLayout(ty: Type, mod: *Module) bool {
711	.anyerror,	689	.anyerror,
712	.adhoc_inferred_error_set,	690	.adhoc_inferred_error_set,
713	.anyopaque,	691	.anyopaque,
714	.atomic_order,
715	.atomic_rmw_op,
716	.calling_convention,
717	.address_space,
718	.float_mode,
719	.reduce_op,
720	.call_modifier,
721	.prefetch_options,
722	.export_options,
723	.extern_options,
724	.type,	692	.type,
725	.comptime_int,	693	.comptime_int,
726	.comptime_float,	694	.comptime_float,
...	@@ -728,7 +696,6 @@ pub fn hasWellDefinedLayout(ty: Type, mod: *Module) bool {	...	@@ -728,7 +696,6 @@ pub fn hasWellDefinedLayout(ty: Type, mod: *Module) bool {
728	.null,	696	.null,
729	.undefined,	697	.undefined,
730	.enum_literal,	698	.enum_literal,
731	.type_info,
732	.generic_poison,	699	.generic_poison,
733	=> false,	700	=> false,
734	},	701	},
...	@@ -972,14 +939,6 @@ pub fn abiAlignmentAdvanced(	...	@@ -972,14 +939,6 @@ pub fn abiAlignmentAdvanced(
972		939
973	.simple_type => \|t\| switch (t) {	940	.simple_type => \|t\| switch (t) {
974	.bool,	941	.bool,
975	.atomic_order,
976	.atomic_rmw_op,
977	.calling_convention,
978	.address_space,
979	.float_mode,
980	.reduce_op,
981	.call_modifier,
982	.prefetch_options,
983	.anyopaque,	942	.anyopaque,
984	=> return .{ .scalar = .@"1" },	943	=> return .{ .scalar = .@"1" },
985		944
...	@@ -987,11 +946,6 @@ pub fn abiAlignmentAdvanced(	...	@@ -987,11 +946,6 @@ pub fn abiAlignmentAdvanced(
987	.isize,	946	.isize,
988	=> return .{ .scalar = intAbiAlignment(target.ptrBitWidth(), target, use_llvm) },	947	=> return .{ .scalar = intAbiAlignment(target.ptrBitWidth(), target, use_llvm) },
989		948
990	.export_options,
991	.extern_options,
992	.type_info,
993	=> return .{ .scalar = ptrAbiAlignment(target) },
994
995	.c_char => return .{ .scalar = cTypeAlign(target, .char) },	949	.c_char => return .{ .scalar = cTypeAlign(target, .char) },
996	.c_short => return .{ .scalar = cTypeAlign(target, .short) },	950	.c_short => return .{ .scalar = cTypeAlign(target, .short) },
997	.c_ushort => return .{ .scalar = cTypeAlign(target, .ushort) },	951	.c_ushort => return .{ .scalar = cTypeAlign(target, .ushort) },
...	@@ -1352,15 +1306,7 @@ pub fn abiSizeAdvanced(	...	@@ -1352,15 +1306,7 @@ pub fn abiSizeAdvanced(
1352	},	1306	},
1353	.func_type => unreachable, // represents machine code; not a pointer	1307	.func_type => unreachable, // represents machine code; not a pointer
1354	.simple_type => \|t\| switch (t) {	1308	.simple_type => \|t\| switch (t) {
1355	.bool,	1309	.bool => return .{ .scalar = 1 },
1356	.atomic_order,
1357	.atomic_rmw_op,
1358	.calling_convention,
1359	.address_space,
1360	.float_mode,
1361	.reduce_op,
1362	.call_modifier,
1363	=> return .{ .scalar = 1 },
1364		1310
1365	.f16 => return .{ .scalar = 2 },	1311	.f16 => return .{ .scalar = 2 },
1366	.f32 => return .{ .scalar = 4 },	1312	.f32 => return .{ .scalar = 4 },
...	@@ -1402,11 +1348,6 @@ pub fn abiSizeAdvanced(	...	@@ -1402,11 +1348,6 @@ pub fn abiSizeAdvanced(
1402	return .{ .scalar = intAbiSize(bits, target, use_llvm) };	1348	return .{ .scalar = intAbiSize(bits, target, use_llvm) };
1403	},	1349	},
1404		1350
1405	.prefetch_options => unreachable, // missing call to resolveTypeFields
1406	.export_options => unreachable, // missing call to resolveTypeFields
1407	.extern_options => unreachable, // missing call to resolveTypeFields
1408
1409	.type_info => unreachable,
1410	.noreturn => unreachable,	1351	.noreturn => unreachable,
1411	.generic_poison => unreachable,	1352	.generic_poison => unreachable,
1412	},	1353	},
...	@@ -1751,18 +1692,6 @@ pub fn bitSizeAdvanced(	...	@@ -1751,18 +1692,6 @@ pub fn bitSizeAdvanced(
1751	.undefined => unreachable,	1692	.undefined => unreachable,
1752	.enum_literal => unreachable,	1693	.enum_literal => unreachable,
1753	.generic_poison => unreachable,	1694	.generic_poison => unreachable,
1754
1755	.atomic_order => unreachable,
1756	.atomic_rmw_op => unreachable,
1757	.calling_convention => unreachable,
1758	.address_space => unreachable,
1759	.float_mode => unreachable,
1760	.reduce_op => unreachable,
1761	.call_modifier => unreachable,
1762	.prefetch_options => unreachable,
1763	.export_options => unreachable,
1764	.extern_options => unreachable,
1765	.type_info => unreachable,
1766	},	1695	},
1767	.struct_type => {	1696	.struct_type => {
1768	const struct_type = ip.loadStructType(ty.toIntern());	1697	const struct_type = ip.loadStructType(ty.toIntern());
...	@@ -2565,17 +2494,6 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {	...	@@ -2565,17 +2494,6 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {
2565	.comptime_int,	2494	.comptime_int,
2566	.comptime_float,	2495	.comptime_float,
2567	.enum_literal,	2496	.enum_literal,
2568	.atomic_order,
2569	.atomic_rmw_op,
2570	.calling_convention,
2571	.address_space,
2572	.float_mode,
2573	.reduce_op,
2574	.call_modifier,
2575	.prefetch_options,
2576	.export_options,
2577	.extern_options,
2578	.type_info,
2579	.adhoc_inferred_error_set,	2497	.adhoc_inferred_error_set,
2580	=> return null,	2498	=> return null,
2581		2499
...	@@ -2782,16 +2700,6 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: Resolve	...	@@ -2782,16 +2700,6 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: Resolve
2782	.adhoc_inferred_error_set,	2700	.adhoc_inferred_error_set,
2783	.noreturn,	2701	.noreturn,
2784	.generic_poison,	2702	.generic_poison,
2785	.atomic_order,
2786	.atomic_rmw_op,
2787	.calling_convention,
2788	.address_space,
2789	.float_mode,
2790	.reduce_op,
2791	.call_modifier,
2792	.prefetch_options,
2793	.export_options,
2794	.extern_options,
2795	=> false,	2703	=> false,
2796		2704
2797	.type,	2705	.type,
...	@@ -2800,7 +2708,6 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: Resolve	...	@@ -2800,7 +2708,6 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: Resolve
2800	.null,	2708	.null,
2801	.undefined,	2709	.undefined,
2802	.enum_literal,	2710	.enum_literal,
2803	.type_info,
2804	=> true,	2711	=> true,
2805	},	2712	},
2806	.struct_type => {	2713	.struct_type => {
...	@@ -3534,10 +3441,6 @@ pub fn packedStructFieldPtrInfo(struct_ty: Type, parent_ptr_ty: Type, field_idx:	...	@@ -3534,10 +3441,6 @@ pub fn packedStructFieldPtrInfo(struct_ty: Type, parent_ptr_ty: Type, field_idx:
3534	pub fn resolveLayout(ty: Type, pt: Zcu.PerThread) SemaError!void {	3441	pub fn resolveLayout(ty: Type, pt: Zcu.PerThread) SemaError!void {
3535	const zcu = pt.zcu;	3442	const zcu = pt.zcu;
3536	const ip = &zcu.intern_pool;	3443	const ip = &zcu.intern_pool;
3537	switch (ip.indexToKey(ty.toIntern())) {
3538	.simple_type => \|simple_type\| return resolveSimpleType(simple_type, pt),
3539	else => {},
3540	}
3541	switch (ty.zigTypeTag(zcu)) {	3444	switch (ty.zigTypeTag(zcu)) {
3542	.Struct => switch (ip.indexToKey(ty.toIntern())) {	3445	.Struct => switch (ip.indexToKey(ty.toIntern())) {
3543	.anon_struct_type => \|anon_struct_type\| for (0..anon_struct_type.types.len) \|i\| {	3446	.anon_struct_type => \|anon_struct_type\| for (0..anon_struct_type.types.len) \|i\| {
...	@@ -3651,8 +3554,6 @@ pub fn resolveFields(ty: Type, pt: Zcu.PerThread) SemaError!void {	...	@@ -3651,8 +3554,6 @@ pub fn resolveFields(ty: Type, pt: Zcu.PerThread) SemaError!void {
3651	.one_u8 => unreachable,	3554	.one_u8 => unreachable,
3652	.four_u8 => unreachable,	3555	.four_u8 => unreachable,
3653	.negative_one => unreachable,	3556	.negative_one => unreachable,
3654	.calling_convention_c => unreachable,
3655	.calling_convention_inline => unreachable,
3656	.void_value => unreachable,	3557	.void_value => unreachable,
3657	.unreachable_value => unreachable,	3558	.unreachable_value => unreachable,
3658	.null_value => unreachable,	3559	.null_value => unreachable,
...	@@ -3669,8 +3570,6 @@ pub fn resolveFields(ty: Type, pt: Zcu.PerThread) SemaError!void {	...	@@ -3669,8 +3570,6 @@ pub fn resolveFields(ty: Type, pt: Zcu.PerThread) SemaError!void {
3669		3570
3670	.type_union => return ty.resolveUnionInner(pt, .fields),	3571	.type_union => return ty.resolveUnionInner(pt, .fields),
3671		3572
3672	.simple_type => return resolveSimpleType(ip.indexToKey(ty_ip).simple_type, pt),
3673
3674	else => {},	3573	else => {},
3675	},	3574	},
3676	}	3575	}
...	@@ -3680,11 +3579,6 @@ pub fn resolveFully(ty: Type, pt: Zcu.PerThread) SemaError!void {	...	@@ -3680,11 +3579,6 @@ pub fn resolveFully(ty: Type, pt: Zcu.PerThread) SemaError!void {
3680	const zcu = pt.zcu;	3579	const zcu = pt.zcu;
3681	const ip = &zcu.intern_pool;	3580	const ip = &zcu.intern_pool;
3682		3581
3683	switch (ip.indexToKey(ty.toIntern())) {
3684	.simple_type => \|simple_type\| return resolveSimpleType(simple_type, pt),
3685	else => {},
3686	}
3687
3688	switch (ty.zigTypeTag(zcu)) {	3582	switch (ty.zigTypeTag(zcu)) {
3689	.Type,	3583	.Type,
3690	.Void,	3584	.Void,
...	@@ -3850,28 +3744,6 @@ fn resolveUnionInner(	...	@@ -3850,28 +3744,6 @@ fn resolveUnionInner(
3850	};	3744	};
3851	}	3745	}
3852		3746
3853	/// Fully resolves a simple type. This is usually a nop, but for builtin types with
3854	/// special InternPool indices (such as std.builtin.Type) it will analyze and fully
3855	/// resolve the type.
3856	fn resolveSimpleType(simple_type: InternPool.SimpleType, pt: Zcu.PerThread) Allocator.Error!void {
3857	const builtin_type_name: []const u8 = switch (simple_type) {
3858	.atomic_order => "AtomicOrder",
3859	.atomic_rmw_op => "AtomicRmwOp",
3860	.calling_convention => "CallingConvention",
3861	.address_space => "AddressSpace",
3862	.float_mode => "FloatMode",
3863	.reduce_op => "ReduceOp",
3864	.call_modifier => "CallModifer",
3865	.prefetch_options => "PrefetchOptions",
3866	.export_options => "ExportOptions",
3867	.extern_options => "ExternOptions",
3868	.type_info => "Type",
3869	else => return,
3870	};
3871	// This will fully resolve the type.
3872	_ = try pt.getBuiltinType(builtin_type_name);
3873	}
3874
3875	/// Returns the type of a pointer to an element.	3747	/// Returns the type of a pointer to an element.
3876	/// Asserts that the type is a pointer, and that the element type is indexable.	3748	/// Asserts that the type is a pointer, and that the element type is indexable.
3877	/// If the element index is comptime-known, it must be passed in `offset`.	3749	/// If the element index is comptime-known, it must be passed in `offset`.

src/Zcu.zig+26

...	@@ -3468,3 +3468,29 @@ fn formatDependee(data: struct { dependee: InternPool.Dependee, zcu: *Zcu }, com	...	@@ -3468,3 +3468,29 @@ fn formatDependee(data: struct { dependee: InternPool.Dependee, zcu: *Zcu }, com
3468	},	3468	},
3469	}	3469	}
3470	}	3470	}
		3471
		3472	/// Given the `InternPool.Index` of a function, set its resolved IES to `.none` if it
		3473	/// may be outdated. `Sema` should do this before ever loading a resolved IES.
		3474	pub fn maybeUnresolveIes(zcu: *Zcu, func_index: InternPool.Index) !void {
		3475	const unit = AnalUnit.wrap(.{ .func = func_index });
		3476	if (zcu.outdated.contains(unit) or zcu.potentially_outdated.contains(unit)) {
		3477	// We're consulting the resolved IES now, but the function is outdated, so its
		3478	// IES may have changed. We have to assume the IES is outdated and set the resolved
		3479	// set back to `.none`.
		3480	//
		3481	// This will cause `PerThread.analyzeFnBody` to mark the IES as outdated when it's
		3482	// eventually hit.
		3483	//
		3484	// Since the IES needs to be resolved, the function body will now definitely need
		3485	// re-analysis (even if the IES turns out to be the same!), so mark it as
		3486	// definitely-outdated if it's only PO.
		3487	if (zcu.potentially_outdated.fetchSwapRemove(unit)) \|kv\| {
		3488	const gpa = zcu.gpa;
		3489	try zcu.outdated.putNoClobber(gpa, unit, kv.value);
		3490	if (kv.value == 0) {
		3491	try zcu.outdated_ready.put(gpa, unit, {});
		3492	}
		3493	}
		3494	zcu.intern_pool.funcSetIesResolved(func_index, .none);
		3495	}
		3496	}

src/Zcu/PerThread.zig+29-100

...	@@ -734,31 +734,25 @@ fn ensureFuncBodyAnalyzedInner(	...	@@ -734,31 +734,25 @@ fn ensureFuncBodyAnalyzedInner(
734	const func = zcu.funcInfo(func_index);	734	const func = zcu.funcInfo(func_index);
735	const anal_unit = AnalUnit.wrap(.{ .func = func_index });	735	const anal_unit = AnalUnit.wrap(.{ .func = func_index });
736		736
737	// Here's an interesting question: is this function actually valid?	737	// Make sure that this function is still owned by the same `Nav`. Otherwise, analyzing
738	// Maybe the signature changed, so we'll end up creating a whole different `func`	738	// it would be a waste of time in the best case, and could cause codegen to give bogus
739	// in the InternPool, and this one is a waste of time to analyze. Worse, we'd be	739	// results in the worst case.
740	// analyzing new ZIR with old data, and get bogus errors. They would be unused,	740
741	// but they would still hang around internally! So, let's detect this case.	741	if (func.generic_owner == .none) {
742	// For function decls, we must ensure the declaration's `Cau` is up-to-date, and	742	try pt.ensureCauAnalyzed(ip.getNav(func.owner_nav).analysis_owner.unwrap().?);
743	// check if `func_index` was removed by that update.	743	if (ip.getNav(func.owner_nav).status.resolved.val != func_index) {
744	// For function instances, we do that process on the generic owner.	744	// This function is no longer referenced! There's no point in re-analyzing it.
745		745	// Just mark a transitive failure and move on.
746	try pt.ensureCauAnalyzed(cau: {	746	return error.AnalysisFail;
747	const func_nav = if (func.generic_owner == .none)	747	}
748	func.owner_nav	748	} else {
749	else	749	const go_nav = zcu.funcInfo(func.generic_owner).owner_nav;
750	zcu.funcInfo(func.generic_owner).owner_nav;	750	try pt.ensureCauAnalyzed(ip.getNav(go_nav).analysis_owner.unwrap().?);
751		751	if (ip.getNav(go_nav).status.resolved.val != func.generic_owner) {
752	break :cau ip.getNav(func_nav).analysis_owner.unwrap().?;	752	// The generic owner is no longer referenced, so this function is also unreferenced.
753	});	753	// There's no point in re-analyzing it. Just mark a transitive failure and move on.
754		754	return error.AnalysisFail;
755	if (ip.isRemoved(func_index) or (func.generic_owner != .none and ip.isRemoved(func.generic_owner))) {
756	if (func_outdated) {
757	try zcu.markDependeeOutdated(.marked_po, .{ .interned = func_index }); // IES
758	}	755	}
759	ip.removeDependenciesForDepender(gpa, AnalUnit.wrap(.{ .func = func_index }));
760	ip.remove(pt.tid, func_index);
761	@panic("TODO: remove orphaned function from binary");
762	}	756	}
763		757
764	// We'll want to remember what the IES used to be before the update for	758	// We'll want to remember what the IES used to be before the update for
...	@@ -1108,12 +1102,9 @@ fn semaCau(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) !SemaCauResult {	...	@@ -1108,12 +1102,9 @@ fn semaCau(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) !SemaCauResult {
1108	// We are about to re-analyze this `Cau`; drop its depenndencies.	1102	// We are about to re-analyze this `Cau`; drop its depenndencies.
1109	zcu.intern_pool.removeDependenciesForDepender(gpa, anal_unit);	1103	zcu.intern_pool.removeDependenciesForDepender(gpa, anal_unit);
1110		1104
1111	const builtin_type_target_index: InternPool.Index = switch (cau.owner.unwrap()) {	1105	switch (cau.owner.unwrap()) {
1112	.none => ip_index: {	1106	.none => {}, // `comptime` decl -- we will re-analyze its body.
1113	// `comptime` decl -- we will re-analyze its body.	1107	.nav => {}, // Other decl -- we will re-analyze its value.
1114	// This declaration has no value so is definitely not a std.builtin type.
1115	break :ip_index .none;
1116	},
1117	.type => \|ty\| {	1108	.type => \|ty\| {
1118	// This is an incremental update, and this type is being re-analyzed because it is outdated.	1109	// This is an incremental update, and this type is being re-analyzed because it is outdated.
1119	// Create a new type in its place, and mark the old one as outdated so that use sites will	1110	// Create a new type in its place, and mark the old one as outdated so that use sites will
...	@@ -1125,53 +1116,7 @@ fn semaCau(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) !SemaCauResult {	...	@@ -1125,53 +1116,7 @@ fn semaCau(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) !SemaCauResult {
1125	.invalidate_decl_ref = true,	1116	.invalidate_decl_ref = true,
1126	};	1117	};
1127	},	1118	},
1128	.nav => \|nav\| ip_index: {	1119	}
1129	// Other decl -- we will re-analyze its value.
1130	// This might be a type in `builtin.zig` -- check.
1131	if (file.mod != zcu.std_mod) break :ip_index .none;
1132	// We're in the std module.
1133	const nav_name = ip.getNav(nav).name;
1134	const std_file_imported = try pt.importPkg(zcu.std_mod);
1135	const std_type = Type.fromInterned(zcu.fileRootType(std_file_imported.file_index));
1136	const std_namespace = zcu.namespacePtr(std_type.getNamespace(zcu).unwrap().?);
1137	const builtin_str = try ip.getOrPutString(gpa, pt.tid, "builtin", .no_embedded_nulls);
1138	const builtin_nav = ip.getNav(std_namespace.pub_decls.getKeyAdapted(builtin_str, Zcu.Namespace.NameAdapter{ .zcu = zcu }) orelse break :ip_index .none);
1139	const builtin_namespace = switch (builtin_nav.status) {
1140	.unresolved => break :ip_index .none,
1141	.resolved => \|r\| Type.fromInterned(r.val).getNamespace(zcu).unwrap().?,
1142	};
1143	if (cau.namespace != builtin_namespace) break :ip_index .none;
1144	// We're in builtin.zig. This could be a builtin we need to add to a specific InternPool index.
1145	for ([_][]const u8{
1146	"AtomicOrder",
1147	"AtomicRmwOp",
1148	"CallingConvention",
1149	"AddressSpace",
1150	"FloatMode",
1151	"ReduceOp",
1152	"CallModifier",
1153	"PrefetchOptions",
1154	"ExportOptions",
1155	"ExternOptions",
1156	"Type",
1157	}, [_]InternPool.Index{
1158	.atomic_order_type,
1159	.atomic_rmw_op_type,
1160	.calling_convention_type,
1161	.address_space_type,
1162	.float_mode_type,
1163	.reduce_op_type,
1164	.call_modifier_type,
1165	.prefetch_options_type,
1166	.export_options_type,
1167	.extern_options_type,
1168	.type_info_type,
1169	}) \|type_name, type_ip\| {
1170	if (nav_name.eqlSlice(type_name, ip)) break :ip_index type_ip;
1171	}
1172	break :ip_index .none;
1173	},
1174	};
1175		1120
1176	const is_usingnamespace = switch (cau.owner.unwrap()) {	1121	const is_usingnamespace = switch (cau.owner.unwrap()) {
1177	.nav => \|nav\| ip.getNav(nav).is_usingnamespace,	1122	.nav => \|nav\| ip.getNav(nav).is_usingnamespace,
...	@@ -1200,7 +1145,6 @@ fn semaCau(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) !SemaCauResult {	...	@@ -1200,7 +1145,6 @@ fn semaCau(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) !SemaCauResult {
1200	.fn_ret_ty = Type.void,	1145	.fn_ret_ty = Type.void,
1201	.fn_ret_ty_ies = null,	1146	.fn_ret_ty_ies = null,
1202	.comptime_err_ret_trace = &comptime_err_ret_trace,	1147	.comptime_err_ret_trace = &comptime_err_ret_trace,
1203	.builtin_type_target_index = builtin_type_target_index,
1204	};	1148	};
1205	defer sema.deinit();	1149	defer sema.deinit();
1206		1150
...	@@ -1255,9 +1199,6 @@ fn semaCau(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) !SemaCauResult {	...	@@ -1255,9 +1199,6 @@ fn semaCau(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) !SemaCauResult {
1255	.type => unreachable, // Handled at top of function.	1199	.type => unreachable, // Handled at top of function.
1256	};	1200	};
1257		1201
1258	// We'll do more work with the Sema. Clear the target type index just in case we analyze any type.
1259	sema.builtin_type_target_index = .none;
1260
1261	const align_src = block.src(.{ .node_offset_var_decl_align = 0 });	1202	const align_src = block.src(.{ .node_offset_var_decl_align = 0 });
1262	const section_src = block.src(.{ .node_offset_var_decl_section = 0 });	1203	const section_src = block.src(.{ .node_offset_var_decl_section = 0 });
1263	const addrspace_src = block.src(.{ .node_offset_var_decl_addrspace = 0 });	1204	const addrspace_src = block.src(.{ .node_offset_var_decl_addrspace = 0 });
...	@@ -2072,6 +2013,9 @@ fn analyzeFnBody(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.SemaError!	...	@@ -2072,6 +2013,9 @@ fn analyzeFnBody(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.SemaError!
2072	errdefer _ = zcu.analysis_in_progress.swapRemove(anal_unit);	2013	errdefer _ = zcu.analysis_in_progress.swapRemove(anal_unit);
2073		2014
2074	func.setAnalysisState(ip, .analyzed);	2015	func.setAnalysisState(ip, .analyzed);
		2016	if (func.analysisUnordered(ip).inferred_error_set) {
		2017	func.setResolvedErrorSet(ip, .none);
		2018	}
2075		2019
2076	// This is the `Cau` corresponding to the `declaration` instruction which the function or its generic owner originates from.	2020	// This is the `Cau` corresponding to the `declaration` instruction which the function or its generic owner originates from.
2077	const decl_cau = ip.getCau(cau: {	2021	const decl_cau = ip.getCau(cau: {
...	@@ -2278,7 +2222,7 @@ fn analyzeFnBody(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.SemaError!	...	@@ -2278,7 +2222,7 @@ fn analyzeFnBody(pt: Zcu.PerThread, func_index: InternPool.Index) Zcu.SemaError!
2278	else => \|e\| return e,	2222	else => \|e\| return e,
2279	};	2223	};
2280	assert(ies.resolved != .none);	2224	assert(ies.resolved != .none);
2281	ip.funcSetIesResolved(func_index, ies.resolved);	2225	func.setResolvedErrorSet(ip, ies.resolved);
2282	}	2226	}
2283		2227
2284	assert(zcu.analysis_in_progress.swapRemove(anal_unit));	2228	assert(zcu.analysis_in_progress.swapRemove(anal_unit));
...	@@ -3352,7 +3296,7 @@ pub fn ensureTypeUpToDate(pt: Zcu.PerThread, ty: InternPool.Index, already_updat	...	@@ -3352,7 +3296,7 @@ pub fn ensureTypeUpToDate(pt: Zcu.PerThread, ty: InternPool.Index, already_updat
3352	break :o o;	3296	break :o o;
3353	};	3297	};
3354	if (!outdated) return ty;	3298	if (!outdated) return ty;
3355	return pt.recreateStructType(ty, key, struct_obj);	3299	return pt.recreateStructType(key, struct_obj);
3356	},	3300	},
3357	.union_type => \|key\| {	3301	.union_type => \|key\| {
3358	const union_obj = ip.loadUnionType(ty);	3302	const union_obj = ip.loadUnionType(ty);
...	@@ -3367,7 +3311,7 @@ pub fn ensureTypeUpToDate(pt: Zcu.PerThread, ty: InternPool.Index, already_updat	...	@@ -3367,7 +3311,7 @@ pub fn ensureTypeUpToDate(pt: Zcu.PerThread, ty: InternPool.Index, already_updat
3367	break :o o;	3311	break :o o;
3368	};	3312	};
3369	if (!outdated) return ty;	3313	if (!outdated) return ty;
3370	return pt.recreateUnionType(ty, key, union_obj);	3314	return pt.recreateUnionType(key, union_obj);
3371	},	3315	},
3372	.enum_type => \|key\| {	3316	.enum_type => \|key\| {
3373	const enum_obj = ip.loadEnumType(ty);	3317	const enum_obj = ip.loadEnumType(ty);
...	@@ -3382,7 +3326,7 @@ pub fn ensureTypeUpToDate(pt: Zcu.PerThread, ty: InternPool.Index, already_updat	...	@@ -3382,7 +3326,7 @@ pub fn ensureTypeUpToDate(pt: Zcu.PerThread, ty: InternPool.Index, already_updat
3382	break :o o;	3326	break :o o;
3383	};	3327	};
3384	if (!outdated) return ty;	3328	if (!outdated) return ty;
3385	return pt.recreateEnumType(ty, key, enum_obj);	3329	return pt.recreateEnumType(key, enum_obj);
3386	},	3330	},
3387	.opaque_type => {	3331	.opaque_type => {
3388	assert(!already_updating);	3332	assert(!already_updating);
...	@@ -3394,7 +3338,6 @@ pub fn ensureTypeUpToDate(pt: Zcu.PerThread, ty: InternPool.Index, already_updat	...	@@ -3394,7 +3338,6 @@ pub fn ensureTypeUpToDate(pt: Zcu.PerThread, ty: InternPool.Index, already_updat
3394		3338
3395	fn recreateStructType(	3339	fn recreateStructType(
3396	pt: Zcu.PerThread,	3340	pt: Zcu.PerThread,
3397	ty: InternPool.Index,
3398	full_key: InternPool.Key.NamespaceType,	3341	full_key: InternPool.Key.NamespaceType,
3399	struct_obj: InternPool.LoadedStructType,	3342	struct_obj: InternPool.LoadedStructType,
3400	) Zcu.SemaError!InternPool.Index {	3343	) Zcu.SemaError!InternPool.Index {
...	@@ -3409,10 +3352,6 @@ fn recreateStructType(	...	@@ -3409,10 +3352,6 @@ fn recreateStructType(
3409	.declared => \|d\| d,	3352	.declared => \|d\| d,
3410	};	3353	};
3411		3354
3412	if (@intFromEnum(ty) <= InternPool.static_len) {
3413	@panic("TODO: recreate resolved builtin type");
3414	}
3415
3416	const inst_info = key.zir_index.resolveFull(ip) orelse return error.AnalysisFail;	3355	const inst_info = key.zir_index.resolveFull(ip) orelse return error.AnalysisFail;
3417	const file = zcu.fileByIndex(inst_info.file);	3356	const file = zcu.fileByIndex(inst_info.file);
3418	if (file.status != .success_zir) return error.AnalysisFail;	3357	if (file.status != .success_zir) return error.AnalysisFail;
...	@@ -3485,7 +3424,6 @@ fn recreateStructType(	...	@@ -3485,7 +3424,6 @@ fn recreateStructType(
3485		3424
3486	fn recreateUnionType(	3425	fn recreateUnionType(
3487	pt: Zcu.PerThread,	3426	pt: Zcu.PerThread,
3488	ty: InternPool.Index,
3489	full_key: InternPool.Key.NamespaceType,	3427	full_key: InternPool.Key.NamespaceType,
3490	union_obj: InternPool.LoadedUnionType,	3428	union_obj: InternPool.LoadedUnionType,
3491	) Zcu.SemaError!InternPool.Index {	3429	) Zcu.SemaError!InternPool.Index {
...	@@ -3500,10 +3438,6 @@ fn recreateUnionType(	...	@@ -3500,10 +3438,6 @@ fn recreateUnionType(
3500	.declared => \|d\| d,	3438	.declared => \|d\| d,
3501	};	3439	};
3502		3440
3503	if (@intFromEnum(ty) <= InternPool.static_len) {
3504	@panic("TODO: recreate resolved builtin type");
3505	}
3506
3507	const inst_info = key.zir_index.resolveFull(ip) orelse return error.AnalysisFail;	3441	const inst_info = key.zir_index.resolveFull(ip) orelse return error.AnalysisFail;
3508	const file = zcu.fileByIndex(inst_info.file);	3442	const file = zcu.fileByIndex(inst_info.file);
3509	if (file.status != .success_zir) return error.AnalysisFail;	3443	if (file.status != .success_zir) return error.AnalysisFail;
...	@@ -3584,7 +3518,6 @@ fn recreateUnionType(	...	@@ -3584,7 +3518,6 @@ fn recreateUnionType(
3584		3518
3585	fn recreateEnumType(	3519	fn recreateEnumType(
3586	pt: Zcu.PerThread,	3520	pt: Zcu.PerThread,
3587	ty: InternPool.Index,
3588	full_key: InternPool.Key.NamespaceType,	3521	full_key: InternPool.Key.NamespaceType,
3589	enum_obj: InternPool.LoadedEnumType,	3522	enum_obj: InternPool.LoadedEnumType,
3590	) Zcu.SemaError!InternPool.Index {	3523	) Zcu.SemaError!InternPool.Index {
...	@@ -3599,10 +3532,6 @@ fn recreateEnumType(	...	@@ -3599,10 +3532,6 @@ fn recreateEnumType(
3599	.declared => \|d\| d,	3532	.declared => \|d\| d,
3600	};	3533	};
3601		3534
3602	if (@intFromEnum(ty) <= InternPool.static_len) {
3603	@panic("TODO: recreate resolved builtin type");
3604	}
3605
3606	const inst_info = key.zir_index.resolveFull(ip) orelse return error.AnalysisFail;	3535	const inst_info = key.zir_index.resolveFull(ip) orelse return error.AnalysisFail;
3607	const file = zcu.fileByIndex(inst_info.file);	3536	const file = zcu.fileByIndex(inst_info.file);
3608	if (file.status != .success_zir) return error.AnalysisFail;	3537	if (file.status != .success_zir) return error.AnalysisFail;

src/codegen/c/Type.zig+1-23

...	@@ -1389,21 +1389,6 @@ pub const Pool = struct {	...	@@ -1389,21 +1389,6 @@ pub const Pool = struct {
1389	.anyframe_type,	1389	.anyframe_type,
1390	.generic_poison_type,	1390	.generic_poison_type,
1391	=> unreachable,	1391	=> unreachable,
1392	.atomic_order_type,
1393	.atomic_rmw_op_type,
1394	.calling_convention_type,
1395	.address_space_type,
1396	.float_mode_type,
1397	.reduce_op_type,
1398	.call_modifier_type,
1399	=> \|ip_index\| return pool.fromType(
1400	allocator,
1401	scratch,
1402	Type.fromInterned(ip.loadEnumType(ip_index).tag_ty),
1403	pt,
1404	mod,
1405	kind,
1406	),
1407	.anyerror_type,	1392	.anyerror_type,
1408	.anyerror_void_error_union_type,	1393	.anyerror_void_error_union_type,
1409	.adhoc_inferred_error_set_type,	1394	.adhoc_inferred_error_set_type,
...	@@ -1459,8 +1444,6 @@ pub const Pool = struct {	...	@@ -1459,8 +1444,6 @@ pub const Pool = struct {
1459	.one_u8,	1444	.one_u8,
1460	.four_u8,	1445	.four_u8,
1461	.negative_one,	1446	.negative_one,
1462	.calling_convention_c,
1463	.calling_convention_inline,
1464	.void_value,	1447	.void_value,
1465	.unreachable_value,	1448	.unreachable_value,
1466	.null_value,	1449	.null_value,
...	@@ -1471,12 +1454,7 @@ pub const Pool = struct {	...	@@ -1471,12 +1454,7 @@ pub const Pool = struct {
1471	.none,	1454	.none,
1472	=> unreachable,	1455	=> unreachable,
1473		1456
1474	//.prefetch_options_type,	1457	_ => \|ip_index\| switch (ip.indexToKey(ip_index)) {
1475	//.export_options_type,
1476	//.extern_options_type,
1477	//.type_info_type,
1478	//_,
1479	else => \|ip_index\| switch (ip.indexToKey(ip_index)) {
1480	.int_type => \|int_info\| return pool.fromIntInfo(allocator, int_info, mod, kind),	1458	.int_type => \|int_info\| return pool.fromIntInfo(allocator, int_info, mod, kind),
1481	.ptr_type => \|ptr_info\| switch (ptr_info.flags.size) {	1459	.ptr_type => \|ptr_info\| switch (ptr_info.flags.size) {
1482	.One, .Many, .C => {	1460	.One, .Many, .C => {

src/codegen/llvm.zig-2

...	@@ -3195,8 +3195,6 @@ pub const Object = struct {	...	@@ -3195,8 +3195,6 @@ pub const Object = struct {
3195	.one_u8,	3195	.one_u8,
3196	.four_u8,	3196	.four_u8,
3197	.negative_one,	3197	.negative_one,
3198	.calling_convention_c,
3199	.calling_convention_inline,
3200	.void_value,	3198	.void_value,
3201	.unreachable_value,	3199	.unreachable_value,
3202	.null_value,	3200	.null_value,

src/link/Dwarf.zig+1-13

...	@@ -2565,19 +2565,7 @@ fn updateType(	...	@@ -2565,19 +2565,7 @@ fn updateType(
2565	try wip_nav.strp(if (type_index == .generic_poison_type) "anytype" else name);	2565	try wip_nav.strp(if (type_index == .generic_poison_type) "anytype" else name);
2566	},	2566	},
2567	.anyerror => return, // delay until flush	2567	.anyerror => return, // delay until flush
2568	.atomic_order,	2568	.adhoc_inferred_error_set => unreachable,
2569	.atomic_rmw_op,
2570	.calling_convention,
2571	.address_space,
2572	.float_mode,
2573	.reduce_op,
2574	.call_modifier,
2575	.prefetch_options,
2576	.export_options,
2577	.extern_options,
2578	.type_info,
2579	.adhoc_inferred_error_set,
2580	=> unreachable,
2581	},	2569	},
2582	.struct_type,	2570	.struct_type,
2583	.union_type,	2571	.union_type,

src/print_zir.zig+7

 @@ -615,6 +615,7 @@ const Writer = struct {
             .restore_err_ret_index => try self.writeRestoreErrRetIndex(stream, extended),
             .closure_get => try self.writeClosureGet(stream, extended),
             .field_parent_ptr => try self.writeFieldParentPtr(stream, extended),
+            .builtin_value => try self.writeBuiltinValue(stream, extended),
         }
     }
 @@ -2782,6 +2783,12 @@ const Writer = struct {
         try self.writeSrcNode(stream, @bitCast(extended.operand));
     }
+    fn writeBuiltinValue(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+        const val: Zir.Inst.BuiltinValue = @enumFromInt(extended.small);
+        try stream.print("{s})) ", .{@tagName(val)});
+        try self.writeSrcNode(stream, @bitCast(extended.operand));
+    }
     fn writeInstRef(self: *Writer, stream: anytype, ref: Zir.Inst.Ref) !void {
         if (ref == .none) {
             return stream.writeAll(".none");

test/incremental/type_becomes_comptime_only created+39

...	@@ -0,0 +1,39 @@
1	#target=x86_64-linux
2	#update=initial version
3	#file=main.zig
4	const SomeType = u32;
5	const S = struct {
6	x: SomeType,
7	fn foo(_: S) void {}
8	};
9	pub fn main() void {
10	const s: S = .{ .x = 456 };
11	s.foo();
12	}
13	#expect_stdout=""
14
15	#update=make S comptime-only
16	#file=main.zig
17	const SomeType = comptime_int;
18	const S = struct {
19	x: SomeType,
20	fn foo(_: S) void {}
21	};
22	pub fn main() void {
23	const s: S = .{ .x = 456 };
24	s.foo();
25	}
26	#expect_stdout=""
27
28	#update=make S runtime again
29	#file=main.zig
30	const SomeType = u16;
31	const S = struct {
32	x: SomeType,
33	fn foo(_: S) void {}
34	};
35	pub fn main() void {
36	const s: S = .{ .x = 456 };
37	s.foo();
38	}
39	#expect_stdout=""

author	Matthew Lugg <mlugg@mlugg.co.uk> 2024-08-19 06:30:54+01:00
committer	GitHub <noreply@github.com> 2024-08-19 06:30:54+01:00
log	54e48f7b7dec96c8cdd1a0a0491554b118767817
tree	0fade2355498d008e8cbe9e7e1d7ac6afdffc8c8
parent	c6677be53bd41e7e9a208fb0c1c9135605c761cb
parent	de49a9a17352a36a0888b03905f207b0584fc269
signature	Signed by PGP key B5690EEEBB952194

Merge pull request #21128 from mlugg/incremental