sema: analyze field init bodies in a second pass

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

@@ -371,6 +371,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,
@@ -401,6 +402,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,
@@ -464,6 +482,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];
         }
 
@@ -498,6 +517,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);
@@ -547,6 +574,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);
@@ -589,6 +638,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,
@@ -2999,14 +3062,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...
@@ -3029,6 +3103,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
@@ -3052,6 +3127,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,
@@ -3064,14 +3140,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,
         };
     };
 };
@@ -3704,6 +3784,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 },
@@ -3720,6 +3801,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 },
@@ -4233,6 +4315,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 };
@@ -4276,6 +4364,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,
@@ -4302,13 +4391,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 },
@@ -5362,6 +5458,7 @@ pub const StructTypeInit = struct {
     is_tuple: bool,
     any_comptime_fields: bool,
     any_default_inits: bool,
+    inits_resolved: bool,
     any_aligned_fields: bool,
 };
 
@@ -5382,6 +5479,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,
@@ -5404,6 +5502,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,
@@ -5414,11 +5513,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);
@@ -5430,7 +5534,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, .{
@@ -5446,6 +5550,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,
@@ -5455,6 +5560,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,
             },
         }),
@@ -5465,6 +5572,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| {
@@ -6465,6 +6573,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)),
 
@@ -6538,6 +6647,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),