wasm2go/transpile/inline_leaf_test.go

package transpile_test

import (
	"bytes"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"

	"github.com/goccy/wasm2go/internal/testfixture"
	"github.com/goccy/wasm2go/transpile"
)

// TestInlineLeafEndToEnd pins the wasm-level leaf inliner: both leaf
// callees of the inline_leaf fixture are spliced into the caller (no
// call survives in the caller body), and the generated program
// computes the exact called-semantics results, exercising params,
// declared-local zero-init, an early return joined by phi, a loop and
// memory stores inside an inlined body.
//
// Expected values: memleaf writes [0,1,2,3] at 64..80 so mem[72]=2;
// leaf(3,5)=8 → run(3)=10; leaf(0,_)=7 (early return) → run(0)=9.
func TestInlineLeafEndToEnd(t *testing.T) {
	bin := testfixture.Wasm(t, "inline_leaf")
	m, err := transpile.Parse(bytes.NewReader(bin))
	if err != nil {
		t.Fatalf("Parse: %v", err)
	}
	restore := transpile.SetMultiPackageThreshold(1 << 30)
	defer restore()
	var buf bytes.Buffer
	res, err := transpile.Translate(&buf, m, transpile.Options{
		Package:          "pkg",
		OutputImportPath: "inltest/pkg",
		PureOnly:         true, // pure keeps the caller body inspectable
	})
	if err != nil {
		t.Fatalf("Translate: %v", err)
	}

	// Shape assertion: the caller (fn2) must contain no calls to fn0/fn1.
	var all strings.Builder
	all.Write(buf.Bytes())
	for _, d := range res.Files {
		all.Write(d)
	}
	src := all.String()
	i := strings.Index(src, "func fn2(")
	if i < 0 {
		t.Fatalf("caller fn2 not found in output")
	}
	body := src[i:]
	if j := strings.Index(body, "\n}"); j >= 0 {
		body = body[:j]
	}
	if strings.Contains(body, "fn0(") || strings.Contains(body, "fn1(") {
		t.Errorf("caller still calls a leaf that should have been inlined:\n%s", body)
	}

	// Behavior assertion: build and run.
	dir := t.TempDir()
	writeFile := func(rel string, data []byte) {
		p := filepath.Join(dir, rel)
		if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
			t.Fatal(err)
		}
		if err := os.WriteFile(p, data, 0o644); err != nil {
			t.Fatal(err)
		}
	}
	writeFile("go.mod", []byte("module inltest\n\ngo 1.25.0\n"))
	writeFile("pkg/gen.go", buf.Bytes())
	for rel, data := range res.Files {
		writeFile("pkg/"+rel, data)
	}
	for name, data := range res.Sidecars {
		writeFile("pkg/"+name, data)
	}
	writeFile("main.go", []byte(`package main

import (
	"fmt"

	"inltest/pkg"
)

func main() {
	m := pkg.New()
	fmt.Println(m.Run(3), m.Run(0))
}
`))
	cmd := exec.Command("go", "run", ".")
	cmd.Dir = dir
	out, err := cmd.CombinedOutput()
	if err != nil {
		t.Fatalf("go run failed: %v\n%s", err, out)
	}
	if got := strings.TrimSpace(string(out)); got != "10 9" {
		t.Fatalf("run(3), run(0) printed %q, want \"10 9\"", got)
	}
}

// TestInlineConstBaseLargeOffsetViaConstsTable pins the arm64
// literal-pool guard for the address shape inlining creates: a callee
// whose address PARAM is a large constant at the call site. After
// inlining + constprop the loads' base is an SSA constant that is
// HOISTED into a local (usage ≥ 2), so the old AST-shape check missed
// it, gc constant-folded the local back into the addressing mode, and
// arm64 assembly failed with "LDPSW ...: constant is not in pool" on
// the SpiderMonkey bundle. The emitter must detect SSA-constant bases
// and route large totals through the _consts table.
func TestInlineConstBaseLargeOffsetViaConstsTable(t *testing.T) {
	bin := testfixture.Wasm(t, "inline_constaddr")
	m, err := transpile.Parse(bytes.NewReader(bin))
	if err != nil {
		t.Fatalf("Parse: %v", err)
	}
	restore := transpile.SetMultiPackageThreshold(1 << 30)
	defer restore()
	var buf bytes.Buffer
	res, err := transpile.Translate(&buf, m, transpile.Options{
		Package:          "pkg",
		OutputImportPath: "inlconst/pkg",
		PureOnly:         true,
	})
	if err != nil {
		t.Fatalf("Translate: %v", err)
	}
	var all strings.Builder
	all.Write(buf.Bytes())
	for _, d := range res.Files {
		all.Write(d)
	}
	src := all.String()
	if !strings.Contains(src, "_consts[") {
		t.Errorf("large constant base addresses must route through _consts; none found:\n%s", src)
	}
	// The raw multi-MB literal must not appear inside an unsafe.Add
	// operand (bare or in a fold-visible `vN + off` shape).
	if strings.Contains(src, "unsafe.Add(mBase, 27000000") || strings.Contains(src, "unsafe.Add(mBase, uint32(27000000") {
		t.Errorf("multi-MB literal reached unsafe.Add directly:\n%s", src)
	}
}

// TestInlineKeepsCalleeBodies pins the exported-shape invariant:
// fn0/fn1 bodies are still emitted even when inlined into callers
// (table/export references may need them; whole-function DCE
// decides, not the inliner).
func TestInlineKeepsCalleeBodies(t *testing.T) {
	bin := testfixture.Wasm(t, "inline_leaf")
	m, err := transpile.Parse(bytes.NewReader(bin))
	if err != nil {
		t.Fatalf("Parse: %v", err)
	}
	restore := transpile.SetMultiPackageThreshold(1 << 30)
	defer restore()
	var buf bytes.Buffer
	res, err := transpile.Translate(&buf, m, transpile.Options{
		Package:          "pkg",
		OutputImportPath: "inltest/pkg",
		PureOnly:         true,
		KeepDeadFuncs:    true, // keep bodies regardless of DCE policy
	})
	if err != nil {
		t.Fatalf("Translate: %v", err)
	}
	var all strings.Builder
	all.Write(buf.Bytes())
	for _, d := range res.Files {
		all.Write(d)
	}
	src := all.String()
	for _, fn := range []string{"func fn0(", "func fn1("} {
		if !strings.Contains(src, fn) {
			t.Errorf("inliner must not delete callee bodies (%s missing); that is DCE's job", fn)
		}
	}
}