Commit 9c95f38a7c1defc7f63a4815bfc2d76a5f9f83f6 | zig

author	Andrew Kelley <andrew@ziglang.org> 2021-08-24 18:56:16-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2021-08-24 22:35:37-07:00
log	9c95f38a7c1defc7f63a4815bfc2d76a5f9f83f6
tree	3182a24f22da9da86b56d8894b4bd603e89e10e3
parent	f1f28af1880a79bb2d7210d3a704c78698f0b45b

stage1: remove incorrect compile error for var redeclaration

Locals are not allowed to shadow declarations, but declarations are
allowed to shadow each other, as long as there are no ambiguous
references.

closes #678

6 files changed, 67 insertions(+), 83 deletions(-)

src
- stage1
  - analyze.cpp
  - astgen.cpp
test
- behavior
- compile_errors.zig

src/stage1/analyze.cpp+4-39

...	@@ -4171,46 +4171,11 @@ ZigVar add_variable(CodeGen g, AstNode source_node, Scope parent_scope, Buf	...	@@ -4171,46 +4171,11 @@ ZigVar add_variable(CodeGen g, AstNode source_node, Scope parent_scope, Buf
4171	} else {	4171	} else {
4172	variable_entry->align_bytes = get_abi_alignment(g, var_type);	4172	variable_entry->align_bytes = get_abi_alignment(g, var_type);
4173		4173
4174	ZigVar *existing_var = find_variable(g, parent_scope, name, nullptr);	4174	ZigType *type;
4175	if (existing_var && !existing_var->shadowable) {	4175	if (get_primitive_type(g, name, &type) != ErrorPrimitiveTypeNotFound) {
4176	if (existing_var->var_type == nullptr \|\| !type_is_invalid(existing_var->var_type)) {	4176	add_node_error(g, source_node,
4177	ErrorMsg *msg = add_node_error(g, source_node,	4177	buf_sprintf("variable shadows primitive type '%s'", buf_ptr(name)));
4178	buf_sprintf("redeclaration of variable '%s'", buf_ptr(name)));
4179	add_error_note(g, msg, existing_var->decl_node, buf_sprintf("previous declaration here"));
4180	}
4181	variable_entry->var_type = g->builtin_types.entry_invalid;	4178	variable_entry->var_type = g->builtin_types.entry_invalid;
4182	} else {
4183	ZigType *type;
4184	if (get_primitive_type(g, name, &type) != ErrorPrimitiveTypeNotFound) {
4185	add_node_error(g, source_node,
4186	buf_sprintf("variable shadows primitive type '%s'", buf_ptr(name)));
4187	variable_entry->var_type = g->builtin_types.entry_invalid;
4188	} else {
4189	Scope *search_scope = nullptr;
4190	if (src_tld == nullptr) {
4191	search_scope = parent_scope;
4192	} else if (src_tld->parent_scope != nullptr && src_tld->parent_scope->parent != nullptr) {
4193	search_scope = src_tld->parent_scope->parent;
4194	}
4195	if (search_scope != nullptr) {
4196	Tld *tld = find_decl(g, search_scope, name);
4197	if (tld != nullptr && tld != src_tld) {
4198	bool want_err_msg = true;
4199	if (tld->id == TldIdVar) {
4200	ZigVar var = reinterpret_cast<TldVar >(tld)->var;
4201	if (var != nullptr && var->var_type != nullptr && type_is_invalid(var->var_type)) {
4202	want_err_msg = false;
4203	}
4204	}
4205	if (want_err_msg) {
4206	ErrorMsg *msg = add_node_error(g, source_node,
4207	buf_sprintf("redefinition of '%s'", buf_ptr(name)));
4208	add_error_note(g, msg, tld->source_node, buf_sprintf("previous definition here"));
4209	}
4210	variable_entry->var_type = g->builtin_types.entry_invalid;
4211	}
4212	}
4213	}
4214	}	4179	}
4215	}	4180	}
4216		4181

src/stage1/astgen.cpp+25-18

 @@ -3200,23 +3200,6 @@ ZigVar *create_local_var(CodeGen *codegen, AstNode *node, Scope *parent_scope,
                     add_node_error(codegen, node,
                             buf_sprintf("variable shadows primitive type '%s'", buf_ptr(name)));
                     variable_entry->var_type = codegen->builtin_types.entry_invalid;
-                } else {
-                    Tld *tld = find_decl(codegen, parent_scope, name);
-                    if (tld != nullptr) {
-                        bool want_err_msg = true;
-                        if (tld->id == TldIdVar) {
-                            ZigVar *var = reinterpret_cast<TldVar *>(tld)->var;
-                            if (var != nullptr && var->var_type != nullptr && type_is_invalid(var->var_type)) {
-                                want_err_msg = false;
-                            }
-                        }
-                        if (want_err_msg) {
-                            ErrorMsg *msg = add_node_error(codegen, node,
-                                    buf_sprintf("redefinition of '%s'", buf_ptr(name)));
-                            add_error_note(codegen, msg, tld->source_node, buf_sprintf("previous definition here"));
-                        }
-                        variable_entry->var_type = codegen->builtin_types.entry_invalid;
-                    }
                 }
             }
         }
 @@ -3875,7 +3858,31 @@ static Stage1ZirInst *astgen_identifier(Stage1AstGen *ag, Scope *scope, AstNode
         }
     }
-    Tld *tld = find_decl(ag->codegen, scope, variable_name);
+    Tld *tld = nullptr;
+    {
+        Scope *s = scope;
+        while (s) {
+            if (s->id == ScopeIdDecls) {
+                ScopeDecls *decls_scope = (ScopeDecls *)s;
+                Tld *result = find_container_decl(ag->codegen, decls_scope, variable_name);
+                if (result != nullptr) {
+                    if (tld != nullptr && tld != result) {
+                        ErrorMsg *msg = add_node_error(ag->codegen, node,
+                                buf_sprintf("ambiguous reference"));
+                        add_error_note(ag->codegen, msg, tld->source_node,
+                                buf_sprintf("declared here"));
+                        add_error_note(ag->codegen, msg, result->source_node,
+                                buf_sprintf("also declared here"));
+                        return ag->codegen->invalid_inst_src;
+                    }
+                    tld = result;
+                }
+            }
+            s = s->parent;
+        }
+    }
     if (tld) {
         Stage1ZirInst *decl_ref = ir_build_decl_ref(ag, scope, node, tld, lval);
         if (lval == LValPtr || lval == LValAssign) {

test/behavior/error.zig+6-6

...	@@ -412,19 +412,19 @@ test "function pointer with return type that is error union with payload which i	...	@@ -412,19 +412,19 @@ test "function pointer with return type that is error union with payload which i
412	test "return result loc as peer result loc in inferred error set function" {	412	test "return result loc as peer result loc in inferred error set function" {
413	const S = struct {	413	const S = struct {
414	fn doTheTest() !void {	414	fn doTheTest() !void {
415	if (foo(2)) \|x\| {	415	if (quux(2)) \|x\| {
416	try expect(x.Two);	416	try expect(x.Two);
417	} else \|e\| switch (e) {	417	} else \|e\| switch (e) {
418	error.Whatever => @panic("fail"),	418	error.Whatever => @panic("fail"),
419	}	419	}
420	try expectError(error.Whatever, foo(99));	420	try expectError(error.Whatever, quux(99));
421	}	421	}
422	const FormValue = union(enum) {	422	const FormValue = union(enum) {
423	One: void,	423	One: void,
424	Two: bool,	424	Two: bool,
425	};	425	};
426		426
427	fn foo(id: u64) !FormValue {	427	fn quux(id: u64) !FormValue {
428	return switch (id) {	428	return switch (id) {
429	2 => FormValue{ .Two = true },	429	2 => FormValue{ .Two = true },
430	1 => FormValue{ .One = {} },	430	1 => FormValue{ .One = {} },
...	@@ -452,11 +452,11 @@ test "error payload type is correctly resolved" {	...	@@ -452,11 +452,11 @@ test "error payload type is correctly resolved" {
452		452
453	test "error union comptime caching" {	453	test "error union comptime caching" {
454	const S = struct {	454	const S = struct {
455	fn foo(comptime arg: anytype) void {	455	fn quux(comptime arg: anytype) void {
456	arg catch {};	456	arg catch {};
457	}	457	}
458	};	458	};
459		459
460	S.foo(@as(anyerror!void, {}));	460	S.quux(@as(anyerror!void, {}));
461	S.foo(@as(anyerror!void, {}));	461	S.quux(@as(anyerror!void, {}));
462	}	462	}

test/behavior/misc.zig+17

...	@@ -505,3 +505,20 @@ test "lazy typeInfo value as generic parameter" {	...	@@ -505,3 +505,20 @@ test "lazy typeInfo value as generic parameter" {
505	};	505	};
506	S.foo(@typeInfo(@TypeOf(.{})));	506	S.foo(@typeInfo(@TypeOf(.{})));
507	}	507	}
		508
		509	fn A() type {
		510	return struct {
		511	b: B(),
		512
		513	const Self = @This();
		514
		515	fn B() type {
		516	return struct {
		517	const Self = @This();
		518	};
		519	}
		520	};
		521	}
		522	test "non-ambiguous reference of shadowed decls" {
		523	try expect(A().B().Self != A().Self);
		524	}

test/behavior/struct.zig+2-2

...	@@ -162,14 +162,14 @@ const MemberFnRand = struct {	...	@@ -162,14 +162,14 @@ const MemberFnRand = struct {
162	};	162	};
163		163
164	test "return struct byval from function" {	164	test "return struct byval from function" {
165	const bar = makeBar(1234, 5678);	165	const bar = makeBar2(1234, 5678);
166	try expect(bar.y == 5678);	166	try expect(bar.y == 5678);
167	}	167	}
168	const Bar = struct {	168	const Bar = struct {
169	x: i32,	169	x: i32,
170	y: i32,	170	y: i32,
171	};	171	};
172	fn makeBar(x: i32, y: i32) Bar {	172	fn makeBar2(x: i32, y: i32) Bar {
173	return Bar{	173	return Bar{
174	.x = x,	174	.x = x,
175	.y = y,	175	.y = y,

test/compile_errors.zig+13-18

 @@ -6969,29 +6969,24 @@ pub fn addCases(ctx: *TestContext) !void {
         "tmp.zig:2:30: error: cannot set section of local variable 'foo'",
     });
-    ctx.objErrStage1("inner struct member shadowing outer struct member",
+    ctx.objErrStage1("ambiguous decl reference",
-        \\fn A() type {
+        \\fn foo() void {}
-        \\    return struct {
+        \\fn bar() void {
-        \\        b: B(),
+        \\    const S = struct {
-        \\
+        \\        fn baz() void {
-        \\        const Self = @This();
+        \\            foo();
-        \\
-        \\        fn B() type {
-        \\            return struct {
-        \\                const Self = @This();
-        \\            };
         \\        }
+        \\        fn foo() void {}
         \\    };
+        \\    S.baz();
         \\}
-        \\comptime {
+        \\export fn entry() void {
-        \\    assert(A().B().Self != A().Self);
+        \\    bar();
-        \\}
-        \\fn assert(ok: bool) void {
-        \\    if (!ok) unreachable;
         \\}
     , &[_][]const u8{
-        "tmp.zig:9:17: error: redefinition of 'Self'",
+        "tmp.zig:5:13: error: ambiguous reference",
-        "tmp.zig:5:9: note: previous definition here",
+        "tmp.zig:7:9: note: declared here",
+        "tmp.zig:1:1: note: also declared here",
     });
     ctx.objErrStage1("while expected bool, got optional",