compiler: eliminate legacy Type.Tag.pointer

Now pointer types are stored only in InternPool.

4 files changed, 63 insertions, 121 deletions

diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index 601382c1fd..c2a108d68e 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -566,8 +566,7 @@ pub const DeclGen = struct {
                 try writer.writeAll("){ .ptr = ");
             }
 
-            var buf: Type.SlicePtrFieldTypeBuffer = undefined;
-            try dg.renderValue(writer, ty.slicePtrFieldType(&buf, mod), val.slicePtr(), .Initializer);
+            try dg.renderValue(writer, ty.slicePtrFieldType(mod), val.slicePtr(), .Initializer);
 
             const len_val = try mod.intValue(Type.usize, val.sliceLen(mod));
 
@@ -631,11 +630,7 @@ pub const DeclGen = struct {
                 // Ensure complete type definition is visible before accessing fields.
                 _ = try dg.typeToIndex(field_ptr.container_ty, .complete);
 
-                var container_ptr_pl: Type.Payload.Pointer = .{
-                    .data = ptr_ty.ptrInfo(mod),
-                };
-                container_ptr_pl.data.pointee_type = field_ptr.container_ty;
-                const container_ptr_ty = Type.initPayload(&container_ptr_pl.base);
+                const container_ptr_ty = try mod.adjustPtrTypeChild(ptr_ty, field_ptr.container_ty);
 
                 switch (fieldLocation(
                     field_ptr.container_ty,
@@ -661,11 +656,7 @@ pub const DeclGen = struct {
                         try dg.writeCValue(writer, field);
                     },
                     .byte_offset => |byte_offset| {
-                        var u8_ptr_pl: Type.Payload.Pointer = .{
-                            .data = ptr_ty.ptrInfo(mod),
-                        };
-                        u8_ptr_pl.data.pointee_type = Type.u8;
-                        const u8_ptr_ty = Type.initPayload(&u8_ptr_pl.base);
+                        const u8_ptr_ty = try mod.adjustPtrTypeChild(ptr_ty, Type.u8);
 
                         const byte_offset_val = try mod.intValue(Type.usize, byte_offset);
 
@@ -788,8 +779,7 @@ pub const DeclGen = struct {
                     }
 
                     try writer.writeAll("{(");
-                    var buf: Type.SlicePtrFieldTypeBuffer = undefined;
-                    const ptr_ty = ty.slicePtrFieldType(&buf, mod);
+                    const ptr_ty = ty.slicePtrFieldType(mod);
                     try dg.renderType(writer, ptr_ty);
                     return writer.print("){x}, {0x}}}", .{try dg.fmtIntLiteral(Type.usize, val, .Other)});
                 } else {
@@ -1068,10 +1058,9 @@ pub const DeclGen = struct {
                         }
 
                         const slice = val.castTag(.slice).?.data;
-                        var buf: Type.SlicePtrFieldTypeBuffer = undefined;
 
                         try writer.writeByte('{');
-                        try dg.renderValue(writer, ty.slicePtrFieldType(&buf, mod), slice.ptr, initializer_type);
+                        try dg.renderValue(writer, ty.slicePtrFieldType(mod), slice.ptr, initializer_type);
                         try writer.writeAll(", ");
                         try dg.renderValue(writer, Type.usize, slice.len, initializer_type);
                         try writer.writeByte('}');
@@ -1536,8 +1525,8 @@ pub const DeclGen = struct {
 
         switch (kind) {
             .forward => {},
-            .complete => if (fn_info.alignment > 0)
-                try w.print(" zig_align_fn({})", .{fn_info.alignment}),
+            .complete => if (fn_info.alignment.toByteUnitsOptional()) |a|
+                try w.print(" zig_align_fn({})", .{a}),
             else => unreachable,
         }
 
@@ -1561,8 +1550,8 @@ pub const DeclGen = struct {
         );
 
         switch (kind) {
-            .forward => if (fn_info.alignment > 0)
-                try w.print(" zig_align_fn({})", .{fn_info.alignment}),
+            .forward => if (fn_info.alignment.toByteUnitsOptional()) |a|
+                try w.print(" zig_align_fn({})", .{a}),
             .complete => {},
             else => unreachable,
         }
@@ -4062,8 +4051,7 @@ fn airSlice(f: *Function, inst: Air.Inst.Index) !CValue {
     try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs });
 
     const inst_ty = f.typeOfIndex(inst);
-    var buf: Type.SlicePtrFieldTypeBuffer = undefined;
-    const ptr_ty = inst_ty.slicePtrFieldType(&buf, mod);
+    const ptr_ty = inst_ty.slicePtrFieldType(mod);
 
     const writer = f.object.writer();
     const local = try f.allocLocal(inst, inst_ty);
@@ -5047,7 +5035,6 @@ fn airIsNull(
     const operand_ty = f.typeOf(un_op);
     const optional_ty = if (is_ptr) operand_ty.childType(mod) else operand_ty;
     const payload_ty = optional_ty.optionalChild(mod);
-    var slice_ptr_buf: Type.SlicePtrFieldTypeBuffer = undefined;
 
     const rhs = if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod))
         TypedValue{ .ty = Type.bool, .val = Value.true }
@@ -5058,7 +5045,7 @@ fn airIsNull(
         TypedValue{ .ty = payload_ty, .val = try mod.intValue(payload_ty, 0) }
     else if (payload_ty.isSlice(mod) and optional_ty.optionalReprIsPayload(mod)) rhs: {
         try writer.writeAll(".ptr");
-        const slice_ptr_ty = payload_ty.slicePtrFieldType(&slice_ptr_buf, mod);
+        const slice_ptr_ty = payload_ty.slicePtrFieldType(mod);
         break :rhs TypedValue{ .ty = slice_ptr_ty, .val = Value.null };
     } else rhs: {
         try writer.writeAll(".is_null");
@@ -5278,11 +5265,7 @@ fn airFieldParentPtr(f: *Function, inst: Air.Inst.Index) !CValue {
     switch (fieldLocation(container_ty, field_ptr_ty, extra.field_index, mod)) {
         .begin => try f.writeCValue(writer, field_ptr_val, .Initializer),
         .field => |field| {
-            var u8_ptr_pl: Type.Payload.Pointer = .{
-                .data = field_ptr_ty.ptrInfo(mod),
-            };
-            u8_ptr_pl.data.pointee_type = Type.u8;
-            const u8_ptr_ty = Type.initPayload(&u8_ptr_pl.base);
+            const u8_ptr_ty = try mod.adjustPtrTypeChild(field_ptr_ty, Type.u8);
 
             try writer.writeAll("((");
             try f.renderType(writer, u8_ptr_ty);
@@ -5295,11 +5278,7 @@ fn airFieldParentPtr(f: *Function, inst: Air.Inst.Index) !CValue {
             try writer.writeAll("))");
         },
         .byte_offset => |byte_offset| {
-            var u8_ptr_pl: Type.Payload.Pointer = .{
-                .data = field_ptr_ty.ptrInfo(mod),
-            };
-            u8_ptr_pl.data.pointee_type = Type.u8;
-            const u8_ptr_ty = Type.initPayload(&u8_ptr_pl.base);
+            const u8_ptr_ty = try mod.adjustPtrTypeChild(field_ptr_ty, Type.u8);
 
             const byte_offset_val = try mod.intValue(Type.usize, byte_offset);
 
@@ -5347,11 +5326,7 @@ fn fieldPtr(
             try f.writeCValueDerefMember(writer, container_ptr_val, field);
         },
         .byte_offset => |byte_offset| {
-            var u8_ptr_pl: Type.Payload.Pointer = .{
-                .data = field_ptr_ty.ptrInfo(mod),
-            };
-            u8_ptr_pl.data.pointee_type = Type.u8;
-            const u8_ptr_ty = Type.initPayload(&u8_ptr_pl.base);
+            const u8_ptr_ty = try mod.adjustPtrTypeChild(field_ptr_ty, Type.u8);
 
             const byte_offset_val = try mod.intValue(Type.usize, byte_offset);
 
@@ -5794,8 +5769,7 @@ fn airArrayToSlice(f: *Function, inst: Air.Inst.Index) !CValue {
     // Unfortunately, C does not support any equivalent to
     // &(*(void *)p)[0], although LLVM does via GetElementPtr
     if (operand == .undef) {
-        var buf: Type.SlicePtrFieldTypeBuffer = undefined;
-        try f.writeCValue(writer, .{ .undef = inst_ty.slicePtrFieldType(&buf, mod) }, .Initializer);
+        try f.writeCValue(writer, .{ .undef = inst_ty.slicePtrFieldType(mod) }, .Initializer);
     } else if (array_ty.hasRuntimeBitsIgnoreComptime(mod)) {
         try writer.writeAll("&(");
         try f.writeCValueDeref(writer, operand);
diff --git a/src/codegen/c/type.zig b/src/codegen/c/type.zig
index a2af395a98..70426972af 100644
--- a/src/codegen/c/type.zig
+++ b/src/codegen/c/type.zig
@@ -1431,8 +1431,7 @@ pub const CType = extern union {
                                 .complete, .parameter, .global => try lookup.typeToIndex(ty, .forward),
                                 .payload => unreachable,
                             }) |fwd_idx| {
-                                var buf: Type.SlicePtrFieldTypeBuffer = undefined;
-                                const ptr_ty = ty.slicePtrFieldType(&buf, mod);
+                                const ptr_ty = ty.slicePtrFieldType(mod);
                                 if (try lookup.typeToIndex(ptr_ty, kind)) |ptr_idx| {
                                     self.storage = .{ .anon = undefined };
                                     self.storage.anon.fields[0] = .{
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 476f73cbe4..0c503edee4 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -1591,40 +1591,30 @@ pub const Object = struct {
             },
             .Pointer => {
                 // Normalize everything that the debug info does not represent.
-                const ptr_info = ty.ptrInfo(mod);
+                const ptr_info = ty.ptrInfoIp(mod.intern_pool);
 
-                if (ptr_info.sentinel != null or
-                    ptr_info.@"addrspace" != .generic or
+                if (ptr_info.sentinel != .none or
+                    ptr_info.address_space != .generic or
                     ptr_info.bit_offset != 0 or
                     ptr_info.host_size != 0 or
                     ptr_info.vector_index != .none or
-                    ptr_info.@"allowzero" or
-                    !ptr_info.mutable or
-                    ptr_info.@"volatile" or
+                    ptr_info.is_allowzero or
+                    ptr_info.is_const or
+                    ptr_info.is_volatile or
                     ptr_info.size == .Many or ptr_info.size == .C or
-                    !ptr_info.pointee_type.hasRuntimeBitsIgnoreComptime(mod))
+                    !ptr_info.elem_type.toType().hasRuntimeBitsIgnoreComptime(mod))
                 {
-                    var payload: Type.Payload.Pointer = .{
-                        .data = .{
-                            .pointee_type = ptr_info.pointee_type,
-                            .sentinel = null,
-                            .@"align" = ptr_info.@"align",
-                            .@"addrspace" = .generic,
-                            .bit_offset = 0,
-                            .host_size = 0,
-                            .@"allowzero" = false,
-                            .mutable = true,
-                            .@"volatile" = false,
-                            .size = switch (ptr_info.size) {
-                                .Many, .C, .One => .One,
-                                .Slice => .Slice,
-                            },
+                    const bland_ptr_ty = try mod.ptrType(.{
+                        .elem_type = if (!ptr_info.elem_type.toType().hasRuntimeBitsIgnoreComptime(mod))
+                            .anyopaque_type
+                        else
+                            ptr_info.elem_type,
+                        .alignment = ptr_info.alignment,
+                        .size = switch (ptr_info.size) {
+                            .Many, .C, .One => .One,
+                            .Slice => .Slice,
                         },
-                    };
-                    if (!ptr_info.pointee_type.hasRuntimeBitsIgnoreComptime(mod)) {
-                        payload.data.pointee_type = Type.anyopaque;
-                    }
-                    const bland_ptr_ty = Type.initPayload(&payload.base);
+                    });
                     const ptr_di_ty = try o.lowerDebugType(bland_ptr_ty, resolve);
                     // The recursive call to `lowerDebugType` means we can't use `gop` anymore.
                     try o.di_type_map.putContext(gpa, ty, AnnotatedDITypePtr.init(ptr_di_ty, resolve), .{ .mod = o.module });
@@ -1632,8 +1622,7 @@ pub const Object = struct {
                 }
 
                 if (ty.isSlice(mod)) {
-                    var buf: Type.SlicePtrFieldTypeBuffer = undefined;
-                    const ptr_ty = ty.slicePtrFieldType(&buf, mod);
+                    const ptr_ty = ty.slicePtrFieldType(mod);
                     const len_ty = Type.usize;
 
                     const name = try ty.nameAlloc(gpa, o.module);
@@ -1711,7 +1700,7 @@ pub const Object = struct {
                     return full_di_ty;
                 }
 
-                const elem_di_ty = try o.lowerDebugType(ptr_info.pointee_type, .fwd);
+                const elem_di_ty = try o.lowerDebugType(ptr_info.elem_type.toType(), .fwd);
                 const name = try ty.nameAlloc(gpa, o.module);
                 defer gpa.free(name);
                 const ptr_di_ty = dib.createPointerType(
@@ -2625,8 +2614,8 @@ pub const DeclGen = struct {
             },
         }
 
-        if (fn_info.alignment != 0) {
-            llvm_fn.setAlignment(@intCast(c_uint, fn_info.alignment));
+        if (fn_info.alignment.toByteUnitsOptional()) |a| {
+            llvm_fn.setAlignment(@intCast(c_uint, a));
         }
 
         // Function attributes that are independent of analysis results of the function body.
@@ -2819,8 +2808,7 @@ pub const DeclGen = struct {
             .Bool => return dg.context.intType(1),
             .Pointer => {
                 if (t.isSlice(mod)) {
-                    var buf: Type.SlicePtrFieldTypeBuffer = undefined;
-                    const ptr_type = t.slicePtrFieldType(&buf, mod);
+                    const ptr_type = t.slicePtrFieldType(mod);
 
                     const fields: [2]*llvm.Type = .{
                         try dg.lowerType(ptr_type),
@@ -3176,11 +3164,10 @@ pub const DeclGen = struct {
             },
             .slice => {
                 const param_ty = fn_info.param_types[it.zig_index - 1].toType();
-                var buf: Type.SlicePtrFieldTypeBuffer = undefined;
                 const ptr_ty = if (param_ty.zigTypeTag(mod) == .Optional)
-                    param_ty.optionalChild(mod).slicePtrFieldType(&buf, mod)
+                    param_ty.optionalChild(mod).slicePtrFieldType(mod)
                 else
-                    param_ty.slicePtrFieldType(&buf, mod);
+                    param_ty.slicePtrFieldType(mod);
                 const ptr_llvm_ty = try dg.lowerType(ptr_ty);
                 const len_llvm_ty = try dg.lowerType(Type.usize);
 
@@ -3368,10 +3355,9 @@ pub const DeclGen = struct {
                     },
                     .slice => {
                         const slice = tv.val.castTag(.slice).?.data;
-                        var buf: Type.SlicePtrFieldTypeBuffer = undefined;
                         const fields: [2]*llvm.Value = .{
                             try dg.lowerValue(.{
-                                .ty = tv.ty.slicePtrFieldType(&buf, mod),
+                                .ty = tv.ty.slicePtrFieldType(mod),
                                 .val = slice.ptr,
                             }),
                             try dg.lowerValue(.{
@@ -4171,8 +4157,7 @@ pub const DeclGen = struct {
     ) Error!*llvm.Value {
         const mod = self.module;
         if (tv.ty.isSlice(mod)) {
-            var buf: Type.SlicePtrFieldTypeBuffer = undefined;
-            const ptr_ty = tv.ty.slicePtrFieldType(&buf, mod);
+            const ptr_ty = tv.ty.slicePtrFieldType(mod);
             const fields: [2]*llvm.Value = .{
                 try self.lowerValue(.{
                     .ty = ptr_ty,
@@ -6043,17 +6028,14 @@ pub const FuncGen = struct {
                 const field_ptr = self.builder.buildStructGEP(struct_llvm_ty, struct_llvm_val, llvm_field.index, "");
                 const field_ptr_ty = try mod.ptrType(.{
                     .elem_type = llvm_field.ty.ip_index,
-                    .alignment = llvm_field.alignment,
+                    .alignment = InternPool.Alignment.fromNonzeroByteUnits(llvm_field.alignment),
                 });
                 if (isByRef(field_ty, mod)) {
                     if (canElideLoad(self, body_tail))
                         return field_ptr;
 
-                    const field_alignment = if (llvm_field.alignment != 0)
-                        llvm_field.alignment
-                    else
-                        llvm_field.ty.abiAlignment(mod);
-                    return self.loadByRef(field_ptr, field_ty, field_alignment, false);
+                    assert(llvm_field.alignment != 0);
+                    return self.loadByRef(field_ptr, field_ty, llvm_field.alignment, false);
                 } else {
                     return self.load(field_ptr, field_ptr_ty);
                 }
@@ -6151,7 +6133,7 @@ pub const FuncGen = struct {
         const fn_ty = try mod.funcType(.{
             .param_types = &.{},
             .return_type = .void_type,
-            .alignment = 0,
+            .alignment = .none,
             .noalias_bits = 0,
             .comptime_bits = 0,
             .cc = .Unspecified,
@@ -6655,8 +6637,7 @@ pub const FuncGen = struct {
                 operand;
             if (payload_ty.isSlice(mod)) {
                 const slice_ptr = self.builder.buildExtractValue(loaded, 0, "");
-                var slice_buf: Type.SlicePtrFieldTypeBuffer = undefined;
-                const ptr_ty = try self.dg.lowerType(payload_ty.slicePtrFieldType(&slice_buf, mod));
+                const ptr_ty = try self.dg.lowerType(payload_ty.slicePtrFieldType(mod));
                 return self.builder.buildICmp(pred, slice_ptr, ptr_ty.constNull(), "");
             }
             return self.builder.buildICmp(pred, loaded, optional_llvm_ty.constNull(), "");
@@ -6923,7 +6904,7 @@ pub const FuncGen = struct {
         const field_ptr = self.builder.buildStructGEP(struct_llvm_ty, self.err_ret_trace.?, llvm_field.index, "");
         const field_ptr_ty = try mod.ptrType(.{
             .elem_type = llvm_field.ty.ip_index,
-            .alignment = llvm_field.alignment,
+            .alignment = InternPool.Alignment.fromNonzeroByteUnits(llvm_field.alignment),
         });
         return self.load(field_ptr, field_ptr_ty);
     }
@@ -9319,14 +9300,12 @@ pub const FuncGen = struct {
                         const llvm_i = llvmField(result_ty, i, mod).?.index;
                         indices[1] = llvm_u32.constInt(llvm_i, .False);
                         const field_ptr = self.builder.buildInBoundsGEP(llvm_result_ty, alloca_inst, &indices, indices.len, "");
-                        var field_ptr_payload: Type.Payload.Pointer = .{
-                            .data = .{
-                                .pointee_type = self.typeOf(elem),
-                                .@"align" = result_ty.structFieldAlign(i, mod),
-                                .@"addrspace" = .generic,
-                            },
-                        };
-                        const field_ptr_ty = Type.initPayload(&field_ptr_payload.base);
+                        const field_ptr_ty = try mod.ptrType(.{
+                            .elem_type = self.typeOf(elem).toIntern(),
+                            .alignment = InternPool.Alignment.fromNonzeroByteUnits(
+                                result_ty.structFieldAlign(i, mod),
+                            ),
+                        });
                         try self.store(field_ptr, field_ptr_ty, llvm_elem, .NotAtomic);
                     }
 
@@ -9350,13 +9329,9 @@ pub const FuncGen = struct {
                 const alloca_inst = self.buildAlloca(llvm_result_ty, result_ty.abiAlignment(mod));
 
                 const array_info = result_ty.arrayInfo(mod);
-                var elem_ptr_payload: Type.Payload.Pointer = .{
-                    .data = .{
-                        .pointee_type = array_info.elem_type,
-                        .@"addrspace" = .generic,
-                    },
-                };
-                const elem_ptr_ty = Type.initPayload(&elem_ptr_payload.base);
+                const elem_ptr_ty = try mod.ptrType(.{
+                    .elem_type = array_info.elem_type.toIntern(),
+                });
 
                 for (elements, 0..) |elem, i| {
                     const indices: [2]*llvm.Value = .{
@@ -9476,14 +9451,10 @@ pub const FuncGen = struct {
         // tag and the payload.
         const index_type = self.context.intType(32);
 
-        var field_ptr_payload: Type.Payload.Pointer = .{
-            .data = .{
-                .pointee_type = field.ty,
-                .@"align" = field_align,
-                .@"addrspace" = .generic,
-            },
-        };
-        const field_ptr_ty = Type.initPayload(&field_ptr_payload.base);
+        const field_ptr_ty = try mod.ptrType(.{
+            .elem_type = field.ty.toIntern(),
+            .alignment = InternPool.Alignment.fromNonzeroByteUnits(field_align),
+        });
         if (layout.tag_size == 0) {
             const indices: [3]*llvm.Value = .{
                 index_type.constNull(),
diff --git a/src/codegen/spirv.zig b/src/codegen/spirv.zig
index 777bb1cff9..eada74e6d4 100644
--- a/src/codegen/spirv.zig
+++ b/src/codegen/spirv.zig
@@ -669,8 +669,7 @@ pub const DeclGen = struct {
                     .slice => {
                         const slice = val.castTag(.slice).?.data;
 
-                        var buf: Type.SlicePtrFieldTypeBuffer = undefined;
-                        const ptr_ty = ty.slicePtrFieldType(&buf, mod);
+                        const ptr_ty = ty.slicePtrFieldType(mod);
 
                         try self.lower(ptr_ty, slice.ptr);
                         try self.addInt(Type.usize, slice.len);
@@ -2991,9 +2990,8 @@ pub const DeclGen = struct {
         if (optional_ty.optionalReprIsPayload(mod)) {
             // Pointer payload represents nullability: pointer or slice.
 
-            var ptr_buf: Type.SlicePtrFieldTypeBuffer = undefined;
             const ptr_ty = if (payload_ty.isSlice(mod))
-                payload_ty.slicePtrFieldType(&ptr_buf, mod)
+                payload_ty.slicePtrFieldType(mod)
             else
                 payload_ty;