Commit 9d6bef49a5fc2a5387734fa8d8cc698f0da8d5fa | zig

author	Jimmi Holst Christensen <jhc@dismail.de> 2022-01-07 18:58:40+01:00
committer	Jimmi Holst Christensen <jhc@dismail.de> 2022-01-07 22:10:36+01:00
log	9d6bef49a5fc2a5387734fa8d8cc698f0da8d5fa
tree	86304781ddc0b37b2b7881b54f72fb789660c7eb
parent	d5093b6c1395d4a60a923e1911321784ce368bda

Add two more resolution status' to Struct and Union

resolveTypeForCodegen is called when we needed to resolve a type fully,
even through pointer. This commit fully implements this, even through
pointer fields on structs and unions.

The function has now also been renamed to resolveTypeFully

3 files changed, 116 insertions(+), 19 deletions(-)

src/Module.zig+41-1

...	@@ -831,6 +831,10 @@ pub const Struct = struct {	...	@@ -831,6 +831,10 @@ pub const Struct = struct {
831	have_field_types,	831	have_field_types,
832	layout_wip,	832	layout_wip,
833	have_layout,	833	have_layout,
		834	fully_resolved_wip,
		835	// The types and all its fields have had their layout resolved. Even through pointer,
		836	// which `have_layout` does not ensure.
		837	fully_resolved,
834	},	838	},
835	/// If true, definitely nonzero size at runtime. If false, resolving the fields	839	/// If true, definitely nonzero size at runtime. If false, resolving the fields
836	/// is necessary to determine whether it has bits at runtime.	840	/// is necessary to determine whether it has bits at runtime.
...	@@ -889,6 +893,22 @@ pub const Struct = struct {	...	@@ -889,6 +893,22 @@ pub const Struct = struct {
889	.have_field_types,	893	.have_field_types,
890	.layout_wip,	894	.layout_wip,
891	.have_layout,	895	.have_layout,
		896	.fully_resolved_wip,
		897	.fully_resolved,
		898	=> true,
		899	};
		900	}
		901
		902	pub fn haveLayout(s: Struct) bool {
		903	return switch (s.status) {
		904	.none,
		905	.field_types_wip,
		906	.have_field_types,
		907	.layout_wip,
		908	=> false,
		909	.have_layout,
		910	.fully_resolved_wip,
		911	.fully_resolved,
892	=> true,	912	=> true,
893	};	913	};
894	}	914	}
...	@@ -1003,6 +1023,10 @@ pub const Union = struct {	...	@@ -1003,6 +1023,10 @@ pub const Union = struct {
1003	have_field_types,	1023	have_field_types,
1004	layout_wip,	1024	layout_wip,
1005	have_layout,	1025	have_layout,
		1026	fully_resolved_wip,
		1027	// The types and all its fields have had their layout resolved. Even through pointer,
		1028	// which `have_layout` does not ensure.
		1029	fully_resolved,
1006	},	1030	},
1007		1031
1008	pub const Field = struct {	1032	pub const Field = struct {
...	@@ -1033,6 +1057,8 @@ pub const Union = struct {	...	@@ -1033,6 +1057,8 @@ pub const Union = struct {
1033	.have_field_types,	1057	.have_field_types,
1034	.layout_wip,	1058	.layout_wip,
1035	.have_layout,	1059	.have_layout,
		1060	.fully_resolved_wip,
		1061	.fully_resolved,
1036	=> true,	1062	=> true,
1037	};	1063	};
1038	}	1064	}
...	@@ -1102,8 +1128,22 @@ pub const Union = struct {	...	@@ -1102,8 +1128,22 @@ pub const Union = struct {
1102	tag_size: u64,	1128	tag_size: u64,
1103	};	1129	};
1104		1130
		1131	pub fn haveLayout(u: Union) bool {
		1132	return switch (u.status) {
		1133	.none,
		1134	.field_types_wip,
		1135	.have_field_types,
		1136	.layout_wip,
		1137	=> false,
		1138	.have_layout,
		1139	.fully_resolved_wip,
		1140	.fully_resolved,
		1141	=> true,
		1142	};
		1143	}
		1144
1105	pub fn getLayout(u: Union, target: Target, have_tag: bool) Layout {	1145	pub fn getLayout(u: Union, target: Target, have_tag: bool) Layout {
1106	assert(u.status == .have_layout);	1146	assert(u.haveLayout());
1107	var most_aligned_field: u32 = undefined;	1147	var most_aligned_field: u32 = undefined;
1108	var most_aligned_field_size: u64 = undefined;	1148	var most_aligned_field_size: u64 = undefined;
1109	var biggest_field: u32 = undefined;	1149	var biggest_field: u32 = undefined;

src/Sema.zig+72-15

 @@ -4503,14 +4503,14 @@ fn analyzeCall(
             const arg_src = call_src; // TODO: better source location
             if (i < fn_params_len) {
                 const param_ty = func_ty.fnParamType(i);
-                try sema.resolveTypeForCodegen(block, arg_src, param_ty);
+                try sema.resolveTypeFully(block, arg_src, param_ty);
                 args[i] = try sema.coerce(block, param_ty, uncasted_arg, arg_src);
             } else {
                 args[i] = uncasted_arg;
             }
         }
-        try sema.resolveTypeForCodegen(block, call_src, func_ty_info.return_type);
+        try sema.resolveTypeFully(block, call_src, func_ty_info.return_type);
         try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Call).Struct.fields.len +
             args.len);
 @@ -4580,7 +4580,7 @@ fn finishGenericCall(
                 const param_ty = new_fn_ty.fnParamType(runtime_i);
                 const arg_src = call_src; // TODO: better source location
                 const uncasted_arg = uncasted_args[total_i];
-                try sema.resolveTypeForCodegen(block, arg_src, param_ty);
+                try sema.resolveTypeFully(block, arg_src, param_ty);
                 const casted_arg = try sema.coerce(block, param_ty, uncasted_arg, arg_src);
                 runtime_args[runtime_i] = casted_arg;
                 runtime_i += 1;
 @@ -4588,7 +4588,7 @@ fn finishGenericCall(
             total_i += 1;
         }
-        try sema.resolveTypeForCodegen(block, call_src, new_fn_ty.fnReturnType());
+        try sema.resolveTypeFully(block, call_src, new_fn_ty.fnReturnType());
     }
     try sema.air_extra.ensureUnusedCapacity(sema.gpa, @typeInfo(Air.Call).Struct.fields.len +
         runtime_args_len);
 @@ -15228,7 +15228,7 @@ fn resolveStructLayout(
         .field_types_wip, .layout_wip => {
             return sema.fail(block, src, "struct {} depends on itself", .{ty});
         },
-        .have_layout => return,
+        .have_layout, .fully_resolved_wip, .fully_resolved => return,
     }
     struct_obj.status = .layout_wip;
     for (struct_obj.fields.values()) |field| {
 @@ -15250,7 +15250,7 @@ fn resolveUnionLayout(
         .field_types_wip, .layout_wip => {
             return sema.fail(block, src, "union {} depends on itself", .{ty});
         },
-        .have_layout => return,
+        .have_layout, .fully_resolved_wip, .fully_resolved => return,
     }
     union_obj.status = .layout_wip;
     for (union_obj.fields.values()) |field| {
 @@ -15259,7 +15259,7 @@ fn resolveUnionLayout(
     union_obj.status = .have_layout;
 }
-fn resolveTypeForCodegen(
+fn resolveTypeFully(
     sema: *Sema,
     block: *Block,
     src: LazySrcLoc,
 @@ -15268,20 +15268,67 @@ fn resolveTypeForCodegen(
     switch (ty.zigTypeTag()) {
         .Pointer => {
             const child_ty = try sema.resolveTypeFields(block, src, ty.childType());
-            return resolveTypeForCodegen(sema, block, src, child_ty);
+            return resolveTypeFully(sema, block, src, child_ty);
         },
-        .Struct => return resolveStructLayout(sema, block, src, ty),
+        .Struct => return resolveStructFully(sema, block, src, ty),
-        .Union => return resolveUnionLayout(sema, block, src, ty),
+        .Union => return resolveUnionFully(sema, block, src, ty),
-        .Array => return resolveTypeForCodegen(sema, block, src, ty.childType()),
+        .Array => return resolveTypeFully(sema, block, src, ty.childType()),
         .Optional => {
             var buf: Type.Payload.ElemType = undefined;
-            return resolveTypeForCodegen(sema, block, src, ty.optionalChild(&buf));
+            return resolveTypeFully(sema, block, src, ty.optionalChild(&buf));
         },
-        .ErrorUnion => return resolveTypeForCodegen(sema, block, src, ty.errorUnionPayload()),
+        .ErrorUnion => return resolveTypeFully(sema, block, src, ty.errorUnionPayload()),
         else => {},
     }
 }
+fn resolveStructFully(
+    sema: *Sema,
+    block: *Block,
+    src: LazySrcLoc,
+    ty: Type,
+) CompileError!void {
+    try resolveStructLayout(sema, block, src, ty);
+    const resolved_ty = try sema.resolveTypeFields(block, src, ty);
+    const struct_obj = resolved_ty.castTag(.@"struct").?.data;
+    switch (struct_obj.status) {
+        .none, .have_field_types, .field_types_wip, .layout_wip, .have_layout => {},
+        .fully_resolved_wip, .fully_resolved => return,
+    }
+    // After we have resolve struct layout we have to go over the fields again to
+    // make sure pointer fields get their child types resolved as well
+    struct_obj.status = .fully_resolved_wip;
+    for (struct_obj.fields.values()) |field| {
+        try sema.resolveTypeFully(block, src, field.ty);
+    }
+    struct_obj.status = .fully_resolved;
+}
+fn resolveUnionFully(
+    sema: *Sema,
+    block: *Block,
+    src: LazySrcLoc,
+    ty: Type,
+) CompileError!void {
+    try resolveUnionLayout(sema, block, src, ty);
+    const resolved_ty = try sema.resolveTypeFields(block, src, ty);
+    const union_obj = resolved_ty.cast(Type.Payload.Union).?.data;
+    switch (union_obj.status) {
+        .none, .have_field_types, .field_types_wip, .layout_wip, .have_layout => {},
+        .fully_resolved_wip, .fully_resolved => return,
+    }
+    // Same goes for unions (see comment about structs)
+    union_obj.status = .fully_resolved_wip;
+    for (union_obj.fields.values()) |field| {
+        try sema.resolveTypeFully(block, src, field.ty);
+    }
+    union_obj.status = .fully_resolved;
+}
 fn resolveTypeFields(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) CompileError!Type {
     switch (ty.tag()) {
         .@"struct" => {
 @@ -15291,7 +15338,12 @@ fn resolveTypeFields(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) Comp
                 .field_types_wip => {
                     return sema.fail(block, src, "struct {} depends on itself", .{ty});
                 },
-                .have_field_types, .have_layout, .layout_wip => return ty,
+                .have_field_types,
+                .have_layout,
+                .layout_wip,
+                .fully_resolved_wip,
+                .fully_resolved,
+                => return ty,
             }
             struct_obj.status = .field_types_wip;
 @@ -15324,7 +15376,12 @@ fn resolveTypeFields(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) Comp
                 .field_types_wip => {
                     return sema.fail(block, src, "union {} depends on itself", .{ty});
                 },
-                .have_field_types, .have_layout, .layout_wip => return ty,
+                .have_field_types,
+                .have_layout,
+                .layout_wip,
+                .fully_resolved_wip,
+                .fully_resolved,
+                => return ty,
             }
             union_obj.status = .field_types_wip;

src/type.zig+3-3

...	@@ -1916,7 +1916,7 @@ pub const Type = extern union {	...	@@ -1916,7 +1916,7 @@ pub const Type = extern union {
1916	const fields = self.structFields();	1916	const fields = self.structFields();
1917	const is_packed = if (self.castTag(.@"struct")) \|payload\| p: {	1917	const is_packed = if (self.castTag(.@"struct")) \|payload\| p: {
1918	const struct_obj = payload.data;	1918	const struct_obj = payload.data;
1919	assert(struct_obj.status == .have_layout);	1919	assert(struct_obj.haveLayout());
1920	break :p struct_obj.layout == .Packed;	1920	break :p struct_obj.layout == .Packed;
1921	} else false;	1921	} else false;
1922		1922
...	@@ -2220,7 +2220,7 @@ pub const Type = extern union {	...	@@ -2220,7 +2220,7 @@ pub const Type = extern union {
2220	if (field_count == 0) return 0;	2220	if (field_count == 0) return 0;
2221		2221
2222	const struct_obj = ty.castTag(.@"struct").?.data;	2222	const struct_obj = ty.castTag(.@"struct").?.data;
2223	assert(struct_obj.status == .have_layout);	2223	assert(struct_obj.haveLayout());
2224		2224
2225	var total: u64 = 0;	2225	var total: u64 = 0;
2226	for (struct_obj.fields.values()) \|field\| {	2226	for (struct_obj.fields.values()) \|field\| {
...	@@ -3771,7 +3771,7 @@ pub const Type = extern union {	...	@@ -3771,7 +3771,7 @@ pub const Type = extern union {
3771	switch (ty.tag()) {	3771	switch (ty.tag()) {
3772	.@"struct" => {	3772	.@"struct" => {
3773	const struct_obj = ty.castTag(.@"struct").?.data;	3773	const struct_obj = ty.castTag(.@"struct").?.data;
3774	assert(struct_obj.status == .have_layout);	3774	assert(struct_obj.haveLayout());
3775	const is_packed = struct_obj.layout == .Packed;	3775	const is_packed = struct_obj.layout == .Packed;
3776	if (!is_packed) {	3776	if (!is_packed) {
3777	var offset: u64 = 0;	3777	var offset: u64 = 0;