Commit aa78ebaf95af5a3587194d8dbcb101a49c0bb898 | zig

author	Veikka Tuominen <git@vexu.eu> 2022-08-02 19:54:54+03:00
committer	Veikka Tuominen <git@vexu.eu> 2022-08-03 16:45:33+03:00
log	aa78ebaf95af5a3587194d8dbcb101a49c0bb898
tree	9bcaccf99a4460368f9e9bafc9032d6167864e92
parent	797ded47f05ce033be58d3fb78d777ec3218048b

Sema: improve circular dependency errors

10 files changed, 156 insertions(+), 78 deletions(-)

src
- Sema.zig
test
- cases
  - compile_errors
    direct_struct_loop.zig
    indirect_struct_loop.zig
    instantiating_an_undefined_value_for_an_invalid_struct_that_contains_itself.zig
    instantiating_an_undefined_value_for_an_invalid_union_that_contains_itself.zig
    stage1
    obj
    direct_struct_loop.zig
    indirect_struct_loop.zig
    instantiating_an_undefined_value_for_an_invalid_struct_that_contains_itself.zig
    struct_depends_on_itself_via_optional_field.zig
    struct_depends_on_itself_via_optional_field.zig

src/Sema.zig+83-26

 @@ -26629,21 +26629,41 @@ fn resolveStructLayout(
         switch (struct_obj.status) {
             .none, .have_field_types => {},
             .field_types_wip, .layout_wip => {
-                return sema.fail(block, src, "struct '{}' depends on itself", .{ty.fmt(sema.mod)});
+                const msg = try Module.ErrorMsg.create(
+                    sema.gpa,
+                    struct_obj.srcLoc(sema.mod),
+                    "struct '{}' depends on itself",
+                    .{ty.fmt(sema.mod)},
+                );
+                return sema.failWithOwnedErrorMsg(msg);
             },
             .have_layout, .fully_resolved_wip, .fully_resolved => return,
         }
         struct_obj.status = .layout_wip;
-        for (struct_obj.fields.values()) |field| {
+        for (struct_obj.fields.values()) |field, i| {
-            try sema.resolveTypeLayout(block, src, field.ty);
+            sema.resolveTypeLayout(block, src, field.ty) catch |err| switch (err) {
+                error.AnalysisFail => {
+                    const msg = sema.err orelse return err;
+                    try sema.addFieldErrNote(block, ty, i, msg, "while checking this field", .{});
+                    return err;
+                },
+                else => return err,
+            };
         }
         struct_obj.status = .have_layout;
         // In case of querying the ABI alignment of this struct, we will ask
         // for hasRuntimeBits() of each field, so we need "requires comptime"
         // to be known already before this function returns.
-        for (struct_obj.fields.values()) |field| {
+        for (struct_obj.fields.values()) |field, i| {
-            _ = try sema.typeRequiresComptime(block, src, field.ty);
+            _ = sema.typeRequiresComptime(block, src, field.ty) catch |err| switch (err) {
+                error.AnalysisFail => {
+                    const msg = sema.err orelse return err;
+                    try sema.addFieldErrNote(block, ty, i, msg, "while checking this field", .{});
+                    return err;
+                },
+                else => return err,
+            };
         }
     }
     // otherwise it's a tuple; no need to resolve anything
 @@ -26660,13 +26680,26 @@ fn resolveUnionLayout(
     switch (union_obj.status) {
         .none, .have_field_types => {},
         .field_types_wip, .layout_wip => {
-            return sema.fail(block, src, "union '{}' depends on itself", .{ty.fmt(sema.mod)});
+            const msg = try Module.ErrorMsg.create(
+                sema.gpa,
+                union_obj.srcLoc(sema.mod),
+                "union '{}' depends on itself",
+                .{ty.fmt(sema.mod)},
+            );
+            return sema.failWithOwnedErrorMsg(msg);
         },
         .have_layout, .fully_resolved_wip, .fully_resolved => return,
     }
     union_obj.status = .layout_wip;
-    for (union_obj.fields.values()) |field| {
+    for (union_obj.fields.values()) |field, i| {
-        try sema.resolveTypeLayout(block, src, field.ty);
+        sema.resolveTypeLayout(block, src, field.ty) catch |err| switch (err) {
+            error.AnalysisFail => {
+                const msg = sema.err orelse return err;
+                try sema.addFieldErrNote(block, ty, i, msg, "while checking this field", .{});
+                return err;
+            },
+            else => return err,
+        };
     }
     union_obj.status = .have_layout;
 }
 @@ -26794,12 +26827,12 @@ pub fn resolveTypeFields(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type)
     switch (ty.tag()) {
         .@"struct" => {
             const struct_obj = ty.castTag(.@"struct").?.data;
-            try sema.resolveTypeFieldsStruct(block, src, ty, struct_obj);
+            try sema.resolveTypeFieldsStruct(ty, struct_obj);
             return ty;
         },
         .@"union", .union_safety_tagged, .union_tagged => {
             const union_obj = ty.cast(Type.Payload.Union).?.data;
-            try sema.resolveTypeFieldsUnion(block, src, ty, union_obj);
+            try sema.resolveTypeFieldsUnion(ty, union_obj);
             return ty;
         },
         .type_info => return sema.resolveBuiltinTypeFields(block, src, "Type"),
 @@ -26820,15 +26853,19 @@ pub fn resolveTypeFields(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type)
 fn resolveTypeFieldsStruct(
     sema: *Sema,
-    block: *Block,
-    src: LazySrcLoc,
     ty: Type,
     struct_obj: *Module.Struct,
 ) CompileError!void {
     switch (struct_obj.status) {
         .none => {},
         .field_types_wip => {
-            return sema.fail(block, src, "struct '{}' depends on itself", .{ty.fmt(sema.mod)});
+            const msg = try Module.ErrorMsg.create(
+                sema.gpa,
+                struct_obj.srcLoc(sema.mod),
+                "struct '{}' depends on itself",
+                .{ty.fmt(sema.mod)},
+            );
+            return sema.failWithOwnedErrorMsg(msg);
         },
         .have_field_types,
         .have_layout,
 @@ -26842,17 +26879,17 @@ fn resolveTypeFieldsStruct(
     try semaStructFields(sema.mod, struct_obj);
 }
-fn resolveTypeFieldsUnion(
+fn resolveTypeFieldsUnion(sema: *Sema, ty: Type, union_obj: *Module.Union) CompileError!void {
-    sema: *Sema,
-    block: *Block,
-    src: LazySrcLoc,
-    ty: Type,
-    union_obj: *Module.Union,
-) CompileError!void {
     switch (union_obj.status) {
         .none => {},
         .field_types_wip => {
-            return sema.fail(block, src, "union '{}' depends on itself", .{ty.fmt(sema.mod)});
+            const msg = try Module.ErrorMsg.create(
+                sema.gpa,
+                union_obj.srcLoc(sema.mod),
+                "union '{}' depends on itself",
+                .{ty.fmt(sema.mod)},
+            );
+            return sema.failWithOwnedErrorMsg(msg);
         },
         .have_field_types,
         .have_layout,
 @@ -27786,9 +27823,19 @@ pub fn typeHasOnePossibleValue(
         .@"struct" => {
             const resolved_ty = try sema.resolveTypeFields(block, src, ty);
             const s = resolved_ty.castTag(.@"struct").?.data;
-            for (s.fields.values()) |value| {
+            for (s.fields.values()) |field, i| {
-                if (value.is_comptime) continue;
+                if (field.is_comptime) continue;
-                if ((try sema.typeHasOnePossibleValue(block, src, value.ty)) == null) {
+                if (field.ty.eql(resolved_ty, sema.mod)) {
+                    const msg = try Module.ErrorMsg.create(
+                        sema.gpa,
+                        s.srcLoc(sema.mod),
+                        "struct '{}' depends on itself",
+                        .{ty.fmt(sema.mod)},
+                    );
+                    try sema.addFieldErrNote(block, resolved_ty, i, msg, "while checking this field", .{});
+                    return sema.failWithOwnedErrorMsg(msg);
+                }
+                if ((try sema.typeHasOnePossibleValue(block, src, field.ty)) == null) {
                     return null;
                 }
             }
 @@ -27854,6 +27901,16 @@ pub fn typeHasOnePossibleValue(
             const tag_val = (try sema.typeHasOnePossibleValue(block, src, union_obj.tag_ty)) orelse
                 return null;
             const only_field = union_obj.fields.values()[0];
+            if (only_field.ty.eql(resolved_ty, sema.mod)) {
+                const msg = try Module.ErrorMsg.create(
+                    sema.gpa,
+                    union_obj.srcLoc(sema.mod),
+                    "union '{}' depends on itself",
+                    .{ty.fmt(sema.mod)},
+                );
+                try sema.addFieldErrNote(block, resolved_ty, 0, msg, "while checking this field", .{});
+                return sema.failWithOwnedErrorMsg(msg);
+            }
             const val_val = (try sema.typeHasOnePossibleValue(block, src, only_field.ty)) orelse
                 return null;
             // TODO make this not allocate. The function in `Type.onePossibleValue`
 @@ -28493,7 +28550,7 @@ pub fn typeRequiresComptime(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Typ
                     if (struct_obj.status == .field_types_wip)
                         return false;
-                    try sema.resolveTypeFieldsStruct(block, src, ty, struct_obj);
+                    try sema.resolveTypeFieldsStruct(ty, struct_obj);
                     struct_obj.requires_comptime = .wip;
                     for (struct_obj.fields.values()) |field| {
 @@ -28518,7 +28575,7 @@ pub fn typeRequiresComptime(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Typ
                     if (union_obj.status == .field_types_wip)
                         return false;
-                    try sema.resolveTypeFieldsUnion(block, src, ty, union_obj);
+                    try sema.resolveTypeFieldsUnion(ty, union_obj);
                     union_obj.requires_comptime = .wip;
                     for (union_obj.fields.values()) |field| {

test/cases/compile_errors/direct_struct_loop.zig created+9

...	@@ -0,0 +1,9 @@
1	const A = struct { a : A, };
2	export fn entry() usize { return @sizeOf(A); }
3
4	// error
5	// backend=stage2
6	// target=native
7	//
8	// :1:11: error: struct 'tmp.A' depends on itself
9	// :1:20: note: while checking this field

test/cases/compile_errors/indirect_struct_loop.zig created+13

...	@@ -0,0 +1,13 @@
1	const A = struct { b : B, };
2	const B = struct { c : C, };
3	const C = struct { a : A, };
4	export fn entry() usize { return @sizeOf(A); }
5
6	// error
7	// backend=stage2
8	// target=native
9	//
10	// :1:11: error: struct 'tmp.A' depends on itself
11	// :3:20: note: while checking this field
12	// :2:20: note: while checking this field
13	// :1:20: note: while checking this field

test/cases/compile_errors/instantiating_an_undefined_value_for_an_invalid_struct_that_contains_itself.zig created+16

...	@@ -0,0 +1,16 @@
1	const Foo = struct {
2	x: Foo,
3	};
4
5	var foo: Foo = undefined;
6
7	export fn entry() usize {
8	return @sizeOf(@TypeOf(foo.x));
9	}
10
11	// error
12	// backend=stage2
13	// target=native
14	//
15	// :1:13: error: struct 'tmp.Foo' depends on itself
16	// :2:5: note: while checking this field

test/cases/compile_errors/instantiating_an_undefined_value_for_an_invalid_union_that_contains_itself.zig created+16

...	@@ -0,0 +1,16 @@
1	const Foo = union {
2	x: Foo,
3	};
4
5	var foo: Foo = undefined;
6
7	export fn entry() usize {
8	return @sizeOf(@TypeOf(foo.x));
9	}
10
11	// error
12	// backend=stage2
13	// target=native
14	//
15	// :1:13: error: union 'tmp.Foo' depends on itself
16	// :2:5: note: while checking this field

test/cases/compile_errors/stage1/obj/direct_struct_loop.zig deleted-8

...	@@ -1,8 +0,0 @@
1	const A = struct { a : A, };
2	export fn entry() usize { return @sizeOf(A); }
3
4	// error
5	// backend=stage1
6	// target=native
7	//
8	// tmp.zig:1:11: error: struct 'A' depends on itself

test/cases/compile_errors/stage1/obj/indirect_struct_loop.zig deleted-10

...	@@ -1,10 +0,0 @@
1	const A = struct { b : B, };
2	const B = struct { c : C, };
3	const C = struct { a : A, };
4	export fn entry() usize { return @sizeOf(A); }
5
6	// error
7	// backend=stage1
8	// target=native
9	//
10	// tmp.zig:1:11: error: struct 'A' depends on itself

test/cases/compile_errors/stage1/obj/instantiating_an_undefined_value_for_an_invalid_struct_that_contains_itself.zig deleted-15

...	@@ -1,15 +0,0 @@
1	const Foo = struct {
2	x: Foo,
3	};
4
5	var foo: Foo = undefined;
6
7	export fn entry() usize {
8	return @sizeOf(@TypeOf(foo.x));
9	}
10
11	// error
12	// backend=stage1
13	// target=native
14	//
15	// tmp.zig:1:13: error: struct 'Foo' depends on itself

test/cases/compile_errors/stage1/obj/struct_depends_on_itself_via_optional_field.zig deleted-19

...	@@ -1,19 +0,0 @@
1	const LhsExpr = struct {
2	rhsExpr: ?AstObject,
3	};
4	const AstObject = union {
5	lhsExpr: LhsExpr,
6	};
7	export fn entry() void {
8	const lhsExpr = LhsExpr{ .rhsExpr = null };
9	const obj = AstObject{ .lhsExpr = lhsExpr };
10	_ = obj;
11	}
12
13	// error
14	// backend=stage1
15	// target=native
16	//
17	// tmp.zig:1:17: error: struct 'LhsExpr' depends on itself
18	// tmp.zig:5:5: note: while checking this field
19	// tmp.zig:2:5: note: while checking this field

test/cases/compile_errors/struct_depends_on_itself_via_optional_field.zig created+19

...	@@ -0,0 +1,19 @@
1	const LhsExpr = struct {
2	rhsExpr: ?AstObject,
3	};
4	const AstObject = union {
5	lhsExpr: LhsExpr,
6	};
7	export fn entry() void {
8	const lhsExpr = LhsExpr{ .rhsExpr = null };
9	const obj = AstObject{ .lhsExpr = lhsExpr };
10	_ = obj;
11	}
12
13	// error
14	// backend=stage2
15	// target=native
16	//
17	// :1:17: error: struct 'tmp.LhsExpr' depends on itself
18	// :5:5: note: while checking this field
19	// :2:5: note: while checking this field