type assertion resolving to wrong type

[dgryski]

~/go/src/github.com/dgryski/bug/aws $ tinygo run main.go
*main.Foo
0
*main.Foo
panic: runtime error at 0x000000010b195139: type assert failed
failed to run compiled binary /var/folders/5b/_hr1d1fd3qn4t9vtfx5p61wm0000gp/T/tinygo3370967634/main: signal: abort trap
~/go/src/github.com/dgryski/bug/aws $ cat main.go
package main

import (
	"reflect"
)

func main() {
	TestCopy1()
	TestCopyIgnoreNilMembers()
}

func TestCopy1() {
	type Foo struct {
		A int
	}
	f1 := &Foo{}
	fcopy := CopyOf(f1)
	f2 := fcopy.(*Foo)
	println(f2.A)
}

func TestCopyIgnoreNilMembers() {
	type Foo struct {
		A *int
	}
	f1 := &Foo{}
	fcopy := CopyOf(f1)
	f2 := fcopy.(*Foo) // BOOM -- checking that it's TestCopy1.Foo instead
	println(f2.A)
}

func CopyOf(src interface{}) (dst interface{}) {
	t := reflect.TypeOf(src)
	println(t.String())
	dsti := reflect.New(t.Elem())
	dst = dsti.Interface()
	return dst
}

[dgryski]

Probably compiler but could also be reflect

[dgryski]

So tweaking getTypeCodeName to include the scope pointer solves the issue, but I'd prefer something better than the ptr address. Maybe some other string identifying the scope?

diff --git a/compiler/interface.go b/compiler/interface.go
index e6366683..ec548c8c 100644
--- a/compiler/interface.go
+++ b/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 "named:" + t.String() + "$local:" + fmt.Sprintf("%p", t.Obj().Parent()), true
                }
                return "named:" + t.String(), false
        case *types.Array:

Suggestions @aykevl ?

[dgryski]

Note that just having the function name is not sufficient since we'll still need to handle things like

func TestCopyIgnoreNilMembers() {
	type Foo struct {
		A *int
	}
	f1 := &Foo{}
	fcopy := CopyOf(f1)
	f2 := fcopy.(*Foo)
	println(f2.A)

	if f2.A == nil {
		type Foo struct {
			A *int
		}
		nestedf1 := &Foo{}
		fcopy := CopyOf(nestedf1)
		nestedf2 := fcopy.(*Foo)
		println(nestedf2.A)
	}
}

where we have two Foo's in different scopes in the same function.

[dgryski]

Seems like scope pointer addresses is in fact the way to go.