all: move -panic=trap support to the compiler/runtime

Support for `-panic=trap` was previously a pass in the optimization
pipeline. This change moves it to the compiler and runtime, which in my
opinion is a much better place.

As a side effect, it also fixes
https://github.com/tinygo-org/tinygo/issues/4161 by trapping inside
runtime.runtimePanicAt and not just runtime.runtimePanic.

This change also adds a test for the list of imported functions. This is
a more generic test where it's easy to add more tests for WebAssembly
file properties, such as exported functions.

main_test.go

@@ -15,11 +15,13 @@ import (
 	"reflect"
 	"regexp"
 	"runtime"
+	"slices"
 	"strings"
 	"sync"
 	"testing"
 	"time"
 
+	"github.com/aykevl/go-wasm"
 	"github.com/tinygo-org/tinygo/builder"
 	"github.com/tinygo-org/tinygo/compileopts"
 	"github.com/tinygo-org/tinygo/goenv"
@@ -404,6 +406,64 @@ func runTestWithConfig(name string, t *testing.T, options compileopts.Options, c
 	}
 }
 
+// Test WebAssembly files for certain properties.
+func TestWebAssembly(t *testing.T) {
+	t.Parallel()
+	type testCase struct {
+		name          string
+		panicStrategy string
+		imports       []string
+	}
+	for _, tc := range []testCase{
+		// Test whether there really are no imports when using -panic=trap. This
+		// tests the bugfix for https://github.com/tinygo-org/tinygo/issues/4161.
+		{name: "panic-default", imports: []string{"wasi_snapshot_preview1.fd_write"}},
+		{name: "panic-trap", panicStrategy: "trap", imports: []string{}},
+	} {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			tmpdir := t.TempDir()
+			options := optionsFromTarget("wasi", sema)
+			options.PanicStrategy = tc.panicStrategy
+			config, err := builder.NewConfig(&options)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			result, err := builder.Build("testdata/trivialpanic.go", ".wasm", tmpdir, config)
+			if err != nil {
+				t.Fatal("failed to build binary:", err)
+			}
+			f, err := os.Open(result.Binary)
+			if err != nil {
+				t.Fatal("could not open output binary:", err)
+			}
+			defer f.Close()
+			module, err := wasm.Parse(f)
+			if err != nil {
+				t.Fatal("could not parse output binary:", err)
+			}
+
+			// Test the list of imports.
+			if tc.imports != nil {
+				var imports []string
+				for _, section := range module.Sections {
+					switch section := section.(type) {
+					case *wasm.SectionImport:
+						for _, symbol := range section.Entries {
+							imports = append(imports, symbol.Module+"."+symbol.Field)
+						}
+					}
+				}
+				if !slices.Equal(imports, tc.imports) {
+					t.Errorf("import list not as expected!\nexpected: %v\nactual:   %v", tc.imports, imports)
+				}
+			}
+		})
+	}
+}
+
 func TestTest(t *testing.T) {
 	t.Parallel()