sema: analyze field init bodies in a second pass

This change allows struct field inits to use layout information
of their own struct without causing a circular dependency.

`semaStructFields` caches the ranges of the init bodies in the `StructType`
trailing data. The init bodies are then resolved by `resolveStructFieldInits`,
which is called before the inits are actually required.

Within the init bodies, the struct decl's instruction is repurposed to refer
to the field type itself. This is to allow us to easily rebuild the inst_map
mapping required for the init body instructions to refer to the field type.

Thanks to @mlugg for the guidance on this one!

Author: kcbanner

src/AstGen.zig

@@ -4948,7 +4948,10 @@ fn structDeclInner(
 
         if (have_value) {
             any_default_inits = true;
-            const ri: ResultInfo = .{ .rl = if (field_type == .none) .none else .{ .coerced_ty = field_type } };
+
+            // The decl_inst is used as here so that we can easily reconstruct a mapping
+            // between it and the field type when the fields inits are analzyed.
+            const ri: ResultInfo = .{ .rl = if (field_type == .none) .none else .{ .coerced_ty = Zir.indexToRef(decl_inst) } };
 
             const default_inst = try expr(&block_scope, &namespace.base, ri, member.ast.value_expr);
             if (!block_scope.endsWithNoReturn()) {

src/InternPool.zig

@@ -370,6 +370,7 @@ pub const Key = union(enum) {
         layout: std.builtin.Type.ContainerLayout,
         field_names: NullTerminatedString.Slice,
         field_types: Index.Slice,
+        field_inits_bodies: InitBody.Slice,
         field_inits: Index.Slice,
         field_aligns: Alignment.Slice,
         runtime_order: RuntimeOrder.Slice,
@@ -400,6 +401,23 @@ pub const Key = union(enum) {
             }
         };
 
+        pub const InitBody = struct {
+            start: Zir.Inst.Index,
+            len: u32,
+
+            pub const Slice = struct {
+                start: u32,
+                len: u32,
+
+                pub fn get(this: @This(), ip: *const InternPool) []InitBody {
+                    // Workaround for not being able to case between slices of different lengths
+                    assert(ip.extra.items.len >= this.start + this.len * 2);
+                    const bodies_ptr: [*]InitBody = @ptrCast(ip.extra.items[this.start..].ptr);
+                    return bodies_ptr[0..this.len];
+                }
+            };
+        };
+
         pub const Offsets = struct {
             start: u32,
             len: u32,
@@ -463,6 +481,7 @@ pub const Key = union(enum) {
 
         pub fn fieldInit(s: @This(), ip: *const InternPool, i: usize) Index {
             if (s.field_inits.len == 0) return .none;
+            assert(s.haveFieldInits(ip));
             return s.field_inits.get(ip)[i];
         }
 
@@ -497,6 +516,14 @@ pub const Key = union(enum) {
             return @ptrCast(&ip.extra.items[self.extra_index + flags_field_index]);
         }
 
+        /// The returned pointer expires with any addition to the `InternPool`.
+        /// Asserts the is not packed.
+        pub fn packedFlagsPtr(self: @This(), ip: *const InternPool) *Tag.TypeStructPacked.Flags {
+            assert(self.layout == .Packed);
+            const flags_field_index = std.meta.fieldIndex(Tag.TypeStructPacked, "flags").?;
+            return @ptrCast(&ip.extra.items[self.extra_index + flags_field_index]);
+        }
+
         pub fn assumeRuntimeBitsIfFieldTypesWip(s: @This(), ip: *InternPool) bool {
             if (s.layout == .Packed) return false;
             const flags_ptr = s.flagsPtr(ip);
@@ -546,6 +573,28 @@ pub const Key = union(enum) {
             s.flagsPtr(ip).alignment_wip = false;
         }
 
+        pub fn setInitsWip(s: @This(), ip: *InternPool) bool {
+            switch (s.layout) {
+                inline else => |layout| {
+                    const flag = if (layout == .Packed)
+                        &s.packedFlagsPtr(ip).field_inits_wip
+                    else
+                        &s.flagsPtr(ip).field_inits_wip;
+
+                    if (flag.*) return true;
+                    flag.* = true;
+                    return false;
+                },
+            }
+        }
+
+        pub fn clearInitsWip(s: @This(), ip: *InternPool) void {
+            switch (s.layout) {
+                .Packed => s.packedFlagsPtr(ip).field_inits_wip = false,
+                .Auto, .Extern => s.flagsPtr(ip).field_inits_wip = false,
+            }
+        }
+
         pub fn setFullyResolved(s: @This(), ip: *InternPool) bool {
             if (s.layout == .Packed) return true;
             const flags_ptr = s.flagsPtr(ip);
@@ -588,6 +637,20 @@ pub const Key = union(enum) {
             return types.len == 0 or types[0] != .none;
         }
 
+        pub fn haveFieldInits(s: @This(), ip: *const InternPool) bool {
+            return switch (s.layout) {
+                .Packed => s.packedFlagsPtr(ip).inits_resolved,
+                .Auto, .Extern => s.flagsPtr(ip).inits_resolved,
+            };
+        }
+
+        pub fn setHaveFieldInits(s: @This(), ip: *InternPool) void {
+            return switch (s.layout) {
+                .Packed => s.packedFlagsPtr(ip).inits_resolved = true,
+                .Auto, .Extern => s.flagsPtr(ip).inits_resolved = true,
+            };
+        }
+
         pub fn haveLayout(s: @This(), ip: *InternPool) bool {
             return switch (s.layout) {
                 .Packed => s.backingIntType(ip).* != .none,
@@ -2985,14 +3048,25 @@ pub const Tag = enum(u8) {
     /// Trailing:
     /// 0. type: Index for each fields_len
     /// 1. name: NullTerminatedString for each fields_len
-    /// 2. init: Index for each fields_len // if tag is type_struct_packed_inits
+    ///
+    /// if tag is type_struct_packed_inits:
+    /// 2. body_indices: Zir.Inst.Index // for each field in declared order, a pair of start index and length.
+    /// 3. init: Index for each fields_len
     pub const TypeStructPacked = struct {
         decl: Module.Decl.Index,
         zir_index: Zir.Inst.Index,
         fields_len: u32,
         namespace: Module.Namespace.OptionalIndex,
         backing_int_ty: Index,
         names_map: MapIndex,
+        flags: Flags,
+
+        pub const Flags = packed struct(u32) {
+            /// Dependency loop detection when resolving field inits.
+            field_inits_wip: bool,
+            inits_resolved: bool,
+            _: u30 = 0,
+        };
     };
 
     /// At first I thought of storing the denormalized data externally, such as...
@@ -3015,6 +3089,7 @@ pub const Tag = enum(u8) {
     ///    names_map: MapIndex,
     ///    name: NullTerminatedString // for each field in declared order
     /// 2. if any_default_inits:
+    ///    body_indices: Zir.Inst.Index // for each field in declared order, a pair of start index and length.
     ///    init: Index // for each field in declared order
     /// 3. if has_namespace:
     ///    namespace: Module.Namespace.Index
@@ -3038,6 +3113,7 @@ pub const Tag = enum(u8) {
             requires_comptime: RequiresComptime,
             is_tuple: bool,
             assumed_runtime_bits: bool,
+            assumed_pointer_aligned: bool,
             has_namespace: bool,
             any_comptime_fields: bool,
             any_default_inits: bool,
@@ -3050,14 +3126,18 @@ pub const Tag = enum(u8) {
             field_types_wip: bool,
             /// Dependency loop detection when resolving struct layout.
             layout_wip: bool,
-            /// Determines whether `size`, `alignment`, runtime field order, and
+            /// Indicates whether `size`, `alignment`, runtime field order, and
             /// field offets are populated.
             layout_resolved: bool,
+            /// Dependency loop detection when resolving field inits.
+            field_inits_wip: bool,
+            /// Indicates whether `field_inits` has been resolved.
+            inits_resolved: bool,
             // The types and all its fields have had their layout resolved. Even through pointer,
             // which `layout_resolved` does not ensure.
             fully_resolved: bool,
 
-            _: u11 = 0,
+            _: u8 = 0,
         };
     };
 };
@@ -3690,6 +3770,7 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
             .layout = .Auto,
             .field_names = .{ .start = 0, .len = 0 },
             .field_types = .{ .start = 0, .len = 0 },
+            .field_inits_bodies = .{ .start = 0, .len = 0 },
             .field_inits = .{ .start = 0, .len = 0 },
             .field_aligns = .{ .start = 0, .len = 0 },
             .runtime_order = .{ .start = 0, .len = 0 },
@@ -3706,6 +3787,7 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
             .layout = .Auto,
             .field_names = .{ .start = 0, .len = 0 },
             .field_types = .{ .start = 0, .len = 0 },
+            .field_inits_bodies = .{ .start = 0, .len = 0 },
             .field_inits = .{ .start = 0, .len = 0 },
             .field_aligns = .{ .start = 0, .len = 0 },
             .runtime_order = .{ .start = 0, .len = 0 },
@@ -4218,6 +4300,12 @@ fn extraStructType(ip: *const InternPool, extra_index: u32) Key.StructType {
         index += fields_len;
         break :t .{ names_map.toOptional(), names };
     };
+    const field_inits_bodies: Key.StructType.InitBody.Slice = t: {
+        if (!s.data.flags.any_default_inits) break :t .{ .start = 0, .len = 0 };
+        const offsets: Key.StructType.InitBody.Slice = .{ .start = index, .len = fields_len };
+        index += fields_len * 2;
+        break :t offsets;
+    };
     const field_inits: Index.Slice = t: {
         if (!s.data.flags.any_default_inits) break :t .{ .start = 0, .len = 0 };
         const inits: Index.Slice = .{ .start = index, .len = fields_len };
@@ -4261,6 +4349,7 @@ fn extraStructType(ip: *const InternPool, extra_index: u32) Key.StructType {
         .field_types = field_types,
         .names_map = names_map,
         .field_names = field_names,
+        .field_inits_bodies = field_inits_bodies,
         .field_inits = field_inits,
         .namespace = namespace,
         .field_aligns = field_aligns,
@@ -4287,13 +4376,20 @@ fn extraPackedStructType(ip: *const InternPool, extra_index: u32, inits: bool) K
             .start = type_struct_packed.end + fields_len,
             .len = fields_len,
         },
-        .field_inits = if (inits) .{
+        .field_inits_bodies = if (inits) .{
             .start = type_struct_packed.end + fields_len * 2,
             .len = fields_len,
         } else .{
             .start = 0,
             .len = 0,
         },
+        .field_inits = if (inits) .{
+            .start = type_struct_packed.end + fields_len * 4,
+            .len = fields_len,
+        } else .{
+            .start = 0,
+            .len = 0,
+        },
         .field_aligns = .{ .start = 0, .len = 0 },
         .runtime_order = .{ .start = 0, .len = 0 },
         .comptime_bits = .{ .start = 0, .len = 0 },
@@ -5340,6 +5436,7 @@ pub const StructTypeInit = struct {
     is_tuple: bool,
     any_comptime_fields: bool,
     any_default_inits: bool,
+    inits_resolved: bool,
     any_aligned_fields: bool,
 };
 
@@ -5360,6 +5457,7 @@ pub fn getStructType(
             .layout = undefined,
             .field_names = undefined,
             .field_types = undefined,
+            .field_inits_bodies = undefined,
             .field_inits = undefined,
             .field_aligns = undefined,
             .runtime_order = undefined,
@@ -5382,6 +5480,7 @@ pub fn getStructType(
             try ip.extra.ensureUnusedCapacity(gpa, @typeInfo(Tag.TypeStructPacked).Struct.fields.len +
                 ini.fields_len + // types
                 ini.fields_len + // names
+                ini.fields_len * 2 + // init bodies
                 ini.fields_len); // inits
             try ip.items.append(gpa, .{
                 .tag = if (ini.any_default_inits) .type_struct_packed_inits else .type_struct_packed,
@@ -5392,11 +5491,16 @@ pub fn getStructType(
                     .namespace = ini.namespace,
                     .backing_int_ty = .none,
                     .names_map = names_map,
+                    .flags = .{
+                        .field_inits_wip = false,
+                        .inits_resolved = ini.inits_resolved,
+                    },
                 }),
             });
             ip.extra.appendNTimesAssumeCapacity(@intFromEnum(Index.none), ini.fields_len);
             ip.extra.appendNTimesAssumeCapacity(@intFromEnum(OptionalNullTerminatedString.none), ini.fields_len);
             if (ini.any_default_inits) {
+                ip.extra.appendNTimesAssumeCapacity(0, ini.fields_len * 2);
                 ip.extra.appendNTimesAssumeCapacity(@intFromEnum(Index.none), ini.fields_len);
             }
             return @enumFromInt(ip.items.len - 1);
@@ -5408,7 +5512,7 @@ pub fn getStructType(
     const comptime_elements_len = if (ini.any_comptime_fields) (ini.fields_len + 31) / 32 else 0;
 
     try ip.extra.ensureUnusedCapacity(gpa, @typeInfo(Tag.TypeStruct).Struct.fields.len +
-        (ini.fields_len * 5) + // types, names, inits, runtime order, offsets
+        (ini.fields_len * 7) + // types, names, init bodies, inits, runtime order, offsets
         align_elements_len + comptime_elements_len +
         2); // names_map + namespace
     try ip.items.append(gpa, .{
@@ -5424,6 +5528,7 @@ pub fn getStructType(
                 .requires_comptime = ini.requires_comptime,
                 .is_tuple = ini.is_tuple,
                 .assumed_runtime_bits = false,
+                .assumed_pointer_aligned = false,
                 .has_namespace = ini.namespace != .none,
                 .any_comptime_fields = ini.any_comptime_fields,
                 .any_default_inits = ini.any_default_inits,
@@ -5433,6 +5538,8 @@ pub fn getStructType(
                 .field_types_wip = false,
                 .layout_wip = false,
                 .layout_resolved = false,
+                .field_inits_wip = false,
+                .inits_resolved = ini.inits_resolved,
                 .fully_resolved = false,
             },
         }),
@@ -5443,6 +5550,7 @@ pub fn getStructType(
         ip.extra.appendNTimesAssumeCapacity(@intFromEnum(OptionalNullTerminatedString.none), ini.fields_len);
     }
     if (ini.any_default_inits) {
+        ip.extra.appendNTimesAssumeCapacity(0, ini.fields_len * 2);
         ip.extra.appendNTimesAssumeCapacity(@intFromEnum(Index.none), ini.fields_len);
     }
     if (ini.namespace.unwrap()) |namespace| {
@@ -6443,6 +6551,7 @@ fn addExtraAssumeCapacity(ip: *InternPool, extra: anytype) u32 {
             Tag.TypePointer.PackedOffset,
             Tag.TypeUnion.Flags,
             Tag.TypeStruct.Flags,
+            Tag.TypeStructPacked.Flags,
             Tag.Variable.Flags,
             => @bitCast(@field(extra, field.name)),
 
@@ -6516,6 +6625,7 @@ fn extraDataTrail(ip: *const InternPool, comptime T: type, index: usize) struct
             Tag.TypePointer.PackedOffset,
             Tag.TypeUnion.Flags,
             Tag.TypeStruct.Flags,
+            Tag.TypeStructPacked.Flags,
             Tag.Variable.Flags,
             FuncAnalysis,
             => @bitCast(int32),