Add support for handling `Interface` in `reflect.Type.AssignableTo()`

[fxamacker]

Some packages like fxamacker/cbor require Type.AssignableTo to support Interface.

There was some prior discussion at fxamacker/cbor#295 (comment).

Projects using packages that require Interface support can encounter panics from the following code.

tinygo/src/reflect/type.go

Lines 956 to 969 in 6384eca

	func (t *rawType) AssignableTo(u Type) bool {
	if t == u.(*rawType) {
	return true
	}
	if u.Kind() == Interface && u.NumMethod() == 0 {
	return true
	}
	if u.Kind() == Interface {
	panic("reflect: unimplemented: AssignableTo with interface")
	}
	return false
	}

If a solution becomes available, I can use some existing tests in fxamacker/cbor to help test it.

[jakebailey]

I just hit this, but using plain encoding/json:

panic: reflect: unimplemented: AssignableTo with interface
Error: failed to run main module `./tsgo-tinygo.wasm`

Caused by:
    0: failed to invoke command default
    1: error while executing at wasm backtrace:
           0: 0x31daf - main!runtime.panicOrGoexit
           1: 0x7534 - main!runtime._panic
           2: 0x986f - main!(*internal/reflectlite.RawType).AssignableTo
           3: 0xa0fd5 - main!interface:{Align:func:{}{basic:int},AssignableTo:func:{named:reflect.Type}{basic:bool},Bits:func:{}{basic:int},CanSeq:func:{}{basic:bool},CanSeq2:func:{}{basic:bool},ChanDir:func:{}{named:internal/reflectlite.ChanDir},Comparable:func:{}{basic:bool},ConvertibleTo:func:{named:reflect.Type}{basic:bool},Elem:func:{}{named:reflect.Type},Field:func:{basic:int}{named:reflect.StructField},FieldAlign:func:{}{basic:int},FieldByIndex:func:{slice:basic:int}{named:reflect.StructField},FieldByName:func:{basic:string}{named:reflect.StructField,basic:bool},FieldByNameFunc:func:{func:{basic:string}{basic:bool}}{named:reflect.StructField,basic:bool},Implements:func:{named:reflect.Type}{basic:bool},In:func:{basic:int}{named:reflect.Type},IsVariadic:func:{}{basic:bool},Key:func:{}{named:reflect.Type},Kind:func:{}{named:internal/reflectlite.Kind},Len:func:{}{basic:int},Method:func:{basic:int}{named:reflect.Method},MethodByName:func:{basic:string}{named:reflect.Method,basic:bool},Name:func:{}{basic:string},NumField:func:{}{basic:int},NumIn:func:{}{basic:int},NumMethod:func:{}{basic:int},NumOut:func:{}{basic:int},Out:func:{basic:int}{named:reflect.Type},OverflowComplex:func:{basic:complex128}{basic:bool},OverflowFloat:func:{basic:float64}{basic:bool},OverflowInt:func:{basic:int64}{basic:bool},OverflowUint:func:{basic:uint64}{basic:bool},PkgPath:func:{}{basic:string},Size:func:{}{basic:uintptr},String:func:{}{basic:string}}.Implements$invoke
           4: 0xb406c - main!encoding/json.newTypeEncoder
           5: 0xae0b2 - main!encoding/json.typeEncoder
           6: 0xa3dbb - main!encoding/json.cachedTypeFields
           7: 0x9d708 - main!(*encoding/json.decodeState).object
           8: 0x8a76b - main!(*encoding/json.decodeState).value
           9: 0x8970f - main!(*encoding/json.decodeState).unmarshal
          10: 0x893e9 - main!encoding/json.Unmarshal

[eliasnaur]

I believe this work is tracked in #4376.

[3ddi]

I just got this panic on go 1.24.2 with a code as simple as:

type Test struct {
	Test string `json:"test"`
}

func main() {
	example := `{"test": "a"}`
	var test Test
	json.Unmarshal([]byte(example), &test)
	fmt.Println("Test: ", test)
}

[jakebailey]

This was really hard to trace down, but this also happens in golang.org/x/tools/go/ast/astutil.Cursor.Replace(), via:

// Replace replaces the current Node with n.
// The replacement node is not walked by Apply.
func (c *Cursor) Replace(n ast.Node) {
	if _, ok := c.node.(*ast.File); ok {
		file, ok := n.(*ast.File)
		if !ok {
			panic("attempt to replace *ast.File with non-*ast.File")
		}
		c.parent.(*ast.Package).Files[c.name] = file
		return
	}

	v := c.field()
	if i := c.Index(); i >= 0 {
		v = v.Index(i)
	}
	v.Set(reflect.ValueOf(n))
}

A more minimal repro of this same case:

package main

import (
	"reflect"
)

type Node interface {
	node()
}

type Foo struct{ X int }
type Bar struct{ Y int }

func (*Foo) node() {}
func (*Bar) node() {}

type Container struct {
	List []Node
}

//go:wasmexport run
func run() uint32 {
	c := &Container{
		List: []Node{&Foo{X: 1}},
	}

	v := reflect.Indirect(reflect.ValueOf(c)).FieldByName("List")

	// Index into it
	elem := v.Index(0)

	elem.Set(reflect.ValueOf(&Bar{Y: 2}))

	if _, ok := c.List[0].(*Bar); ok {
		return 0
	}
	return 1
}

func main() {}

$ GOTOOLCHAIN=go1.25.7 tinygo build -target=wasm-unknown -scheduler=none -o bug.wasm
$ WASMTIME_BACKTRACE_DETAILS=1 wasmtime --invoke run bug.wasm
Error: failed to run main module `bug.wasm`

Caused by:
    0: failed to invoke `run`
    1: error while executing at wasm backtrace:
           0:   0x1e4b - runtime.abort
                           at /usr/local/lib/tinygo/src/runtime/runtime_tinygowasm_unknown.go:29:6
                       - runtime.panicOrGoexit
                           at /usr/local/lib/tinygo/src/runtime/panic.go:81:7
           1:    0x99c - runtime._panic
                           at /usr/local/lib/tinygo/src/runtime/panic.go:55:15
           2:   0x2970 - main.run#wasmexport
                           at /usr/local/lib/tinygo/src/internal/reflectlite/type.go:749:8
    2: wasm trap: wasm `unreachable` instruction executed

Which then breaks my compiling gofumpt via tinygo ☹️