compiler: include the scope in the type code name

compiler/interface.go

@@ -518,7 +518,7 @@ 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
+			return fmt.Sprintf("named:%s$local:%p", t.String(), t.Obj().Parent()), true
 		}
 		return "named:" + t.String(), false
 	case *types.Array:

testdata/interface.go

@@ -1,6 +1,9 @@
 package main
 
-import "time"
+import (
+	"reflect"
+	"time"
+)
 
 func main() {
 	thing := &Thing{"foo"}
@@ -119,6 +122,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 +350,41 @@ 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 *int
+		}
+		nestedf1 := &Foo{}
+		fcopy := copyOf(nestedf1)
+		nestedf2 := fcopy.(*Foo)
+		println(nestedf2.A == nil)
+	}
+}
+
+func copyOf(src interface{}) (dst interface{}) {
+	t := reflect.TypeOf(src)
+	println(t.String())
+	dsti := reflect.New(t.Elem())
+	dst = dsti.Interface()
+	return dst
+}

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