Commit a0670e748ec4914f7fc198422d0815e71e90a54f | zig

author	Andrew Kelley <andrew@ziglang.org> 2021-08-12 13:22:27-04:00
committer	GitHub <noreply@github.com> 2021-08-12 13:22:27-04:00
log	a0670e748ec4914f7fc198422d0815e71e90a54f
tree	4f32c8520102c445752ba882657fb7e9a67854c8
parent	394d287778971c3d06fc401e688fc048cdf9860a
parent	16c11988587ad78cd47ec571e1120c052abd47ed
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #9166 from joachimschmidt557/stage2

stage2 Sema: Add error notes to unresolvable peer types

3 files changed, 105 insertions(+), 11 deletions(-)

src
- Module.zig
- Sema.zig
test
- cases.zig

src/Module.zig+51

...	@@ -4399,6 +4399,57 @@ pub const SwitchProngSrc = union(enum) {	...	@@ -4399,6 +4399,57 @@ pub const SwitchProngSrc = union(enum) {
4399	}	4399	}
4400	};	4400	};
4401		4401
		4402	pub const PeerTypeCandidateSrc = union(enum) {
		4403	/// Do not print out error notes for candidate sources
		4404	none: void,
		4405	/// When we want to know the the src of candidate i, look up at
		4406	/// index i in this slice
		4407	override: []LazySrcLoc,
		4408	/// resolvePeerTypes originates from a @TypeOf(...) call
		4409	typeof_builtin_call_node_offset: i32,
		4410
		4411	pub fn resolve(
		4412	self: PeerTypeCandidateSrc,
		4413	gpa: *Allocator,
		4414	decl: *Decl,
		4415	candidates: usize,
		4416	candidate_i: usize,
		4417	) ?LazySrcLoc {
		4418	@setCold(true);
		4419
		4420	switch (self) {
		4421	.none => {
		4422	return null;
		4423	},
		4424	.override => \|candidate_srcs\| {
		4425	return candidate_srcs[candidate_i];
		4426	},
		4427	.typeof_builtin_call_node_offset => \|node_offset\| {
		4428	if (candidates <= 2) {
		4429	switch (candidate_i) {
		4430	0 => return LazySrcLoc{ .node_offset_builtin_call_arg0 = node_offset },
		4431	1 => return LazySrcLoc{ .node_offset_builtin_call_arg1 = node_offset },
		4432	else => unreachable,
		4433	}
		4434	}
		4435
		4436	const tree = decl.namespace.file_scope.getTree(gpa) catch \|err\| {
		4437	// In this case we emit a warning + a less precise source location.
		4438	log.warn("unable to load {s}: {s}", .{
		4439	decl.namespace.file_scope.sub_file_path, @errorName(err),
		4440	});
		4441	return LazySrcLoc{ .node_offset = 0 };
		4442	};
		4443	const node = decl.relativeToNodeIndex(node_offset);
		4444	const node_datas = tree.nodes.items(.data);
		4445	const params = tree.extra_data[node_datas[node].lhs..node_datas[node].rhs];
		4446
		4447	return LazySrcLoc{ .node_abs = params[candidate_i] };
		4448	},
		4449	}
		4450	}
		4451	};
		4452
4402	pub fn analyzeStructFields(mod: Module, struct_obj: Struct) CompileError!void {	4453	pub fn analyzeStructFields(mod: Module, struct_obj: Struct) CompileError!void {
4403	const tracy = trace(@src());	4454	const tracy = trace(@src());
4404	defer tracy.end();	4455	defer tracy.end();

src/Sema.zig+44-9

 @@ -1496,7 +1496,7 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Inde
     if (ptr_val.castTag(.inferred_alloc)) |inferred_alloc| {
         const peer_inst_list = inferred_alloc.data.stored_inst_list.items;
-        const final_elem_ty = try sema.resolvePeerTypes(block, ty_src, peer_inst_list);
+        const final_elem_ty = try sema.resolvePeerTypes(block, ty_src, peer_inst_list, .none);
         if (var_is_mut) {
             try sema.validateVarType(block, ty_src, final_elem_ty);
         }
 @@ -2103,7 +2103,7 @@ fn analyzeBlockBody(
     // Need to set the type and emit the Block instruction. This allows machine code generation
     // to emit a jump instruction to after the block when it encounters the break.
     try parent_block.instructions.append(gpa, merges.block_inst);
-    const resolved_ty = try sema.resolvePeerTypes(parent_block, src, merges.results.items);
+    const resolved_ty = try sema.resolvePeerTypes(parent_block, src, merges.results.items, .none);
     try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Block).Struct.fields.len +
         child_block.instructions.items.len);
     sema.air_instructions.items(.data)[merges.block_inst] = .{ .ty_pl = .{
 @@ -5325,7 +5325,7 @@ fn zirBitwise(
     const rhs_ty = sema.typeOf(rhs);
     const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
-    const resolved_type = try sema.resolvePeerTypes(block, src, instructions);
+    const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{ .override = &[_]LazySrcLoc{ lhs_src, rhs_src } });
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
     const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
 @@ -5506,7 +5506,7 @@ fn analyzeArithmetic(
     };
     const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
-    const resolved_type = try sema.resolvePeerTypes(block, src, instructions);
+    const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{ .override = &[_]LazySrcLoc{ lhs_src, rhs_src } });
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
     const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
 @@ -5817,7 +5817,7 @@ fn analyzeCmp(
         return sema.cmpNumeric(block, src, lhs, rhs, op, lhs_src, rhs_src);
     }
     const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
-    const resolved_type = try sema.resolvePeerTypes(block, src, instructions);
+    const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{ .override = &[_]LazySrcLoc{ lhs_src, rhs_src } });
     if (!resolved_type.isSelfComparable(is_equality_cmp)) {
         return sema.mod.fail(&block.base, src, "{s} operator not allowed for type '{}'", .{
             @tagName(op), resolved_type,
 @@ -6027,7 +6027,7 @@ fn zirTypeofPeer(
         inst_list[i] = sema.resolveInst(arg_ref);
     }
-    const result_type = try sema.resolvePeerTypes(block, src, inst_list);
+    const result_type = try sema.resolvePeerTypes(block, src, inst_list, .{ .typeof_builtin_call_node_offset = extra.data.src_node });
     return sema.addType(result_type);
 }
 @@ -8966,6 +8966,7 @@ fn resolvePeerTypes(
     block: *Scope.Block,
     src: LazySrcLoc,
     instructions: []Air.Inst.Ref,
+    candidate_srcs: Module.PeerTypeCandidateSrc,
 ) !Type {
     if (instructions.len == 0)
         return Type.initTag(.noreturn);
 @@ -8976,7 +8977,8 @@ fn resolvePeerTypes(
     const target = sema.mod.getTarget();
     var chosen = instructions[0];
-    for (instructions[1..]) |candidate| {
+    var chosen_i: usize = 0;
+    for (instructions[1..]) |candidate, candidate_i| {
         const candidate_ty = sema.typeOf(candidate);
         const chosen_ty = sema.typeOf(chosen);
         if (candidate_ty.eql(chosen_ty))
 @@ -8985,12 +8987,14 @@ fn resolvePeerTypes(
             continue;
         if (chosen_ty.zigTypeTag() == .NoReturn) {
             chosen = candidate;
+            chosen_i = candidate_i + 1;
             continue;
         }
         if (candidate_ty.zigTypeTag() == .Undefined)
             continue;
         if (chosen_ty.zigTypeTag() == .Undefined) {
             chosen = candidate;
+            chosen_i = candidate_i + 1;
             continue;
         }
         if (chosen_ty.isInt() and
 @@ -8999,18 +9003,21 @@ fn resolvePeerTypes(
         {
             if (chosen_ty.intInfo(target).bits < candidate_ty.intInfo(target).bits) {
                 chosen = candidate;
+                chosen_i = candidate_i + 1;
             }
             continue;
         }
         if (chosen_ty.isFloat() and candidate_ty.isFloat()) {
             if (chosen_ty.floatBits(target) < candidate_ty.floatBits(target)) {
                 chosen = candidate;
+                chosen_i = candidate_i + 1;
             }
             continue;
         }
         if (chosen_ty.zigTypeTag() == .ComptimeInt and candidate_ty.isInt()) {
             chosen = candidate;
+            chosen_i = candidate_i + 1;
             continue;
         }
 @@ -9020,6 +9027,7 @@ fn resolvePeerTypes(
         if (chosen_ty.zigTypeTag() == .ComptimeFloat and candidate_ty.isFloat()) {
             chosen = candidate;
+            chosen_i = candidate_i + 1;
             continue;
         }
 @@ -9032,11 +9040,38 @@ fn resolvePeerTypes(
         }
         if (chosen_ty.zigTypeTag() == .EnumLiteral and candidate_ty.zigTypeTag() == .Enum) {
             chosen = candidate;
+            chosen_i = candidate_i + 1;
             continue;
         }
-        // TODO error notes pointing out each type
+        // At this point, we hit a compile error. We need to recover
-        return sema.mod.fail(&block.base, src, "incompatible types: '{}' and '{}'", .{ chosen_ty, candidate_ty });
+        // the source locations.
+        const chosen_src = candidate_srcs.resolve(
+            sema.gpa,
+            block.src_decl,
+            instructions.len,
+            chosen_i,
+        );
+        const candidate_src = candidate_srcs.resolve(
+            sema.gpa,
+            block.src_decl,
+            instructions.len,
+            candidate_i + 1,
+        );
+        const msg = msg: {
+            const msg = try sema.mod.errMsg(&block.base, src, "incompatible types: '{}' and '{}'", .{ chosen_ty, candidate_ty });
+            errdefer msg.destroy(sema.gpa);
+            if (chosen_src) |src_loc|
+                try sema.mod.errNote(&block.base, src_loc, msg, "type '{}' here", .{chosen_ty});
+            if (candidate_src) |src_loc|
+                try sema.mod.errNote(&block.base, src_loc, msg, "type '{}' here", .{candidate_ty});
+            break :msg msg;
+        };
+        return sema.mod.failWithOwnedErrorMsg(&block.base, msg);
     }
     return sema.typeOf(chosen);

test/cases.zig+10-2

 @@ -288,7 +288,11 @@ pub fn addCases(ctx: *TestContext) !void {
             \\pub fn main() void {
             \\    _ = @TypeOf(true, 1);
             \\}
-        , &[_][]const u8{":2:9: error: incompatible types: 'bool' and 'comptime_int'"});
+        , &[_][]const u8{
+            ":2:9: error: incompatible types: 'bool' and 'comptime_int'",
+            ":2:17: note: type 'bool' here",
+            ":2:23: note: type 'comptime_int' here",
+        });
     }
     {
 @@ -1729,7 +1733,11 @@ pub fn addCases(ctx: *TestContext) !void {
             \\    const b = false;
             \\    _ = a & &b;
             \\}
-        , &[_][]const u8{":4:11: error: incompatible types: 'bool' and '*const bool'"});
+        , &[_][]const u8{
+            ":4:11: error: incompatible types: 'bool' and '*const bool'",
+            ":4:9: note: type 'bool' here",
+            ":4:13: note: type '*const bool' here",
+        });
         case.addCompareOutput(
             \\pub fn main() void {