compiler: include the scope in the type code name

Fixes #5180

Author: dgryski

compiler/interface.go

@@ -511,14 +511,38 @@ var basicTypeNames = [...]string{
 	types.UnsafePointer: "unsafe.Pointer",
 }
 
+// return an integer representing this scope in a package.
+func scopeId(pkg *types.Scope, scope *types.Scope) string {
+	var ids []int
+	for scope != pkg {
+		parent := scope.Parent()
+		for i := range parent.NumChildren() {
+			if parent.Child(i) == scope {
+				ids = append(ids, i)
+				scope = scope.Parent()
+				break
+			}
+		}
+	}
+
+	var buf []byte
+	for _, v := range ids {
+		buf = strconv.AppendInt(buf, int64(v), 10)
+		buf = append(buf, ':')
+	}
+
+	return string(buf)
+}
+
 // getTypeCodeName returns a name for this type that can be used in the
 // interface lowering pass to assign type codes as expected by the reflect
 // package. See getTypeCodeNum.
 func getTypeCodeName(t types.Type) (string, bool) {
 	switch t := types.Unalias(t).(type) {
 	case *types.Named:
-		if t.Obj().Parent() != t.Obj().Pkg().Scope() {
-			return "named:" + t.String() + "$local", true
+		parent, pkg := t.Obj().Parent(), t.Obj().Pkg().Scope()
+		if parent != pkg {
+			return fmt.Sprintf("named:%s$local:%s", t.String(), scopeId(pkg, parent)), true
 		}
 		return "named:" + t.String(), false
 	case *types.Array:

testdata/interface.go

@@ -119,6 +119,10 @@ func main() {
 
 	// check that type asserts to interfaces with no methods work
 	emptyintfcrash()
+
+	// These are part of a test that checks that `main.Foo` can refer to 2+ different entities without getting them confused.
+	namedFoo()
+	namedFoo2Nested()
 }
 
 func printItf(val interface{}) {
@@ -343,3 +347,37 @@ func emptyintfcrash() {
 		println("x is", x.(int))
 	}
 }
+
+func namedFoo() {
+	type Foo struct {
+		A int
+	}
+	f1 := &Foo{}
+	fcopy := copyOf(f1)
+	f2 := fcopy.(*Foo)
+	println(f2.A)
+}
+
+func namedFoo2Nested() {
+	type Foo struct {
+		A *int
+	}
+	f1 := &Foo{}
+	fcopy := copyOf(f1)
+	f2 := fcopy.(*Foo)
+	println(f2.A == nil)
+
+	if f2.A == nil {
+		type Foo struct {
+			A *byte
+		}
+		nestedf1 := &Foo{}
+		fcopy := copyOf(nestedf1)
+		nestedf2 := fcopy.(*Foo)
+		println(nestedf2.A == nil)
+	}
+}
+
+func copyOf(src interface{}) (dst interface{}) {
+	return src
+}

testdata/interface.txt

@@ -28,3 +28,9 @@ type is int
 type is *int
 type is **int
 x is 5
+*main.Foo
+0
+*main.Foo
+true
+*main.Foo
+true