tinygo does not treat 'any' as 'equivalent to interface{} in every way' with go1.18?

[dkegel-fastly]

The wasi crash in #2725
can be reproduced on that branch with go1.18 using the command

WASMTIME_BACKTRACE_DETAILS=1 build/tinygo test -target wasi -v -run TestFstat  os

(It also reproduces without wasi, but wasi lets you get a nice backtrace.)

It can be prevented by live-reverting the following change in go1.18:

--- /Users/dkegel/src/go/src/io/fs/fs.go	2022-01-15 18:11:12.000000000 -0800
+++ /usr/local/go/src/io/fs/fs.go	2022-03-15 07:08:05.000000000 -0700
@@ -153,4 +153,4 @@
 	Mode() FileMode     // file mode bits
 	ModTime() time.Time // modification time
 	IsDir() bool        // abbreviation for Mode().IsDir()
-	Sys() interface{}   // underlying data source (can return nil)
+	Sys() any           // underlying data source (can return nil)

[dkegel-fastly]

Slightly simpler reproducer:

package main

import "os"

func main() {
        info, err := os.Stat("main.go")
        if err != nil {
                println("could not stat main.go")
		os.Exit(1)
        }

        println("info.Size() crashes, but if it doesn't, size of main.go is", info.Size())
}

[dkegel-fastly]

Further minimization yielded a smoking gun:

package main

type Stat_t struct {
        UnusedSize      int64
}

type FileInfo interface {
        Size() int64
        Sys() any
}

type fileStat struct {
        size    int64
        sys     Stat_t
}

func (fs *fileStat) Size() int64        { return fs.size }
func (fs *fileStat) Sys() interface{}   { return &fs.sys }   // <- changing return type to any rescues the crash

func Stat(name string) (FileInfo, error) {
        var fs fileStat
        fs.size = 37
        return &fs, nil
}

func main() {
        info, err := Stat("main.go")
        if err != nil {
                println("could not stat main.go")
                return
        }

        println("info.Size() crashes, but if it doesn't, size of main.go is", info.Size())
}

A patch that updates all instances of interface{} to any in tinygo/src lets tests pass. [As QuLogic points out below, it might not be sufficient.]

[QuLogic]

I'm confused; I thought any is strictly an alias of interface{}. If it causes ABI changes, then it seems like a mysterious breakage just waiting to happen for people using tinygo.

[dkegel-fastly]

Well then, I guess that's the bug: the tinygo compiler does not treat 'any' as 'equivalent to interface{} in every way'.

I just verified that the go compiler has no problem with the minimal reproducer.

[dkegel-fastly]

On the theory that some magic 'any' fix comes in via golang.org/x/tools, I tried

$ go version
go version go1.18 darwin/amd64
$ git checkout dkegel-go118
$ go get golang.org/x/tools
$ go mod tidy
$ make test
$ make
$ build/tinygo run ~/tinybug/main.go
panic: runtime error: nil pointer dereference
$ go run ~/tinybug/main.go
info.Size() crashes, but if it doesn't, size of main.go is 37

but alas, the small reproducer still seems to reproduce the problem with tinygo.

[QuLogic]

If you run with -dumpssa or -printir, you can still see mentions of any. But I'm no expert at reading those, so I have no idea if any should still be there, or should instead be eliminated by some optimization pass later.

[dgryski]

Here is an incorrect patch that fixes the issue. However, it does point to what the problem is and suggest what the proper fix might be.

index d2d4b4f4..b2f80cbb 100644
--- a/transform/interface-lowering.go
+++ b/transform/interface-lowering.go
@@ -342,6 +342,7 @@ func (p *lowerInterfacesPass) addInterface(methodsString string) {
 // getSignature returns a new *signatureInfo, creating it if it doesn't already
 // exist.
 func (p *lowerInterfacesPass) getSignature(name string) *signatureInfo {
+       name = strings.ReplaceAll(name, "interface{}", "any")
        if _, ok := p.signatures[name]; !ok {
                p.signatures[name] = &signatureInfo{
                        name: name,

[dgryski]

A better fix:

diff --git a/compiler/interface.go b/compiler/interface.go
index c8b76039..3727fc25 100644
--- a/compiler/interface.go
+++ b/compiler/interface.go
@@ -591,23 +591,31 @@ func signature(sig *types.Signature) string {
                        if i > 0 {
                                s += ", "
                        }
-                       s += sig.Params().At(i).Type().String()
+                       s += emptyInterfaceToAny(sig.Params().At(i).Type().String())
                }
                s += ")"
        }
        if sig.Results().Len() == 0 {
                // keep as-is
        } else if sig.Results().Len() == 1 {
-               s += " " + sig.Results().At(0).Type().String()
+               s += " " + emptyInterfaceToAny(sig.Results().At(0).Type().String())
        } else {
                s += " ("
                for i := 0; i < sig.Results().Len(); i++ {
                        if i > 0 {
                                s += ", "
                        }
-                       s += sig.Results().At(i).Type().String()
+                       s += emptyInterfaceToAny(sig.Results().At(i).Type().String())
                }
                s += ")"
        }
        return s
 }
+
+func emptyInterfaceToAny(typ string) string {
+       if typ == "interface{}" {
+               return "any"
+       }
+
+       return typ
+}

[QuLogic]

Interestingly, if you take the test case and add type any = interface{} at the top, it doesn't crash when compiled with Go 1.17. Is that because any is defined in the same file and not builtin, or is it a 1.17/1.18 difference?

if you do s/any/something/g and add type something = interface{} to the example, will it also crash compiled with Go 1.18?