cl: preserve named rangefunc yield closure types

Author: cpunion

cl/instr.go

@@ -2119,12 +2119,34 @@ func (p *context) callEx(b llssa.Builder, act llssa.DoAction, call *ssa.CallComm
 		}
 	default:
 		fn := p.compileValue(b, cv)
-		args := p.compileValues(b, args, kind)
+		args := p.compileDynamicCallValues(b, call, kind)
 		ret = p.emitDo(b, act, ds, fn, llssa.Builder.Call, args...)
 	}
 	return
 }
 
+func (p *context) compileDynamicCallValues(b llssa.Builder, call *ssa.CallCommon, hasVArg int) []llssa.Expr {
+	args := p.compileValues(b, call.Args, hasVArg)
+	params := call.Signature().Params()
+	n := min(len(call.Args)-hasVArg, params.Len())
+	for i, arg := range call.Args[:n] {
+		want := params.At(i).Type()
+		if needsNamedClosureChange(arg.Type(), want) {
+			args[i] = b.ChangeType(p.type_(want, llssa.InGo), args[i])
+		}
+	}
+	return args
+}
+
+func needsNamedClosureChange(got, want types.Type) bool {
+	if types.Identical(got, want) {
+		return false
+	}
+	_, gotIsFunc := got.Underlying().(*types.Signature)
+	_, wantIsFunc := want.Underlying().(*types.Signature)
+	return gotIsFunc && wantIsFunc && types.Identical(got.Underlying(), want.Underlying())
+}
+
 func (p *context) reflectTypeMethodCheck(call *ssa.CallCommon, method *types.Func) (check llssa.ReflectMethodCheck) {
 	if !isReflectType(call.Value.Type()) {
 		return

cl/named_closure_internal_test.go

@@ -0,0 +1,72 @@
+//go:build !llgo
+
+package cl
+
+import (
+	"go/token"
+	"go/types"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestNeedsNamedClosureChange(t *testing.T) {
+	pkg := types.NewPackage("example.com/p", "p")
+	params := types.NewTuple(types.NewParam(token.NoPos, pkg, "value", types.Typ[types.Int]))
+	results := types.NewTuple(types.NewParam(token.NoPos, pkg, "", types.Typ[types.Bool]))
+	sig := types.NewSignatureType(nil, nil, nil, params, results, false)
+	named := types.NewNamed(types.NewTypeName(token.NoPos, pkg, "Func", nil), sig, nil)
+	different := types.NewSignatureType(nil, nil, nil, nil, results, false)
+
+	tests := []struct {
+		name string
+		got  types.Type
+		want types.Type
+		ok   bool
+	}{
+		{name: "anonymous to named", got: sig, want: named, ok: true},
+		{name: "named to anonymous", got: named, want: sig, ok: true},
+		{name: "identical named", got: named, want: named},
+		{name: "different signatures", got: different, want: named},
+		{name: "non functions", got: types.Typ[types.Int], want: types.Typ[types.Int64]},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := needsNamedClosureChange(tt.got, tt.want); got != tt.ok {
+				t.Fatalf("needsNamedClosureChange(%v, %v) = %v, want %v", tt.got, tt.want, got, tt.ok)
+			}
+		})
+	}
+}
+
+func TestNamedClosureValuesKeepTheirDeclaredType(t *testing.T) {
+	const source = `package main
+
+type Func func(int) bool
+
+func call(fn Func) bool { return fn(1) }
+
+func direct() bool {
+	want := 1
+	return call(func(got int) bool { return got == want })
+}
+
+func iterator() func(Func) {
+	return func(yield Func) { _ = yield(1) }
+}
+
+func ranged() int {
+	n := 0
+	for range iterator() { n++ }
+	return n
+}
+
+func main() {
+	if !direct() || ranged() != 1 { panic("named closure conversion failed") }
+}
+`
+	_, module := mustCompileLLPkgFromSrc(t, source)
+	if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+		t.Fatalf("named closure module is invalid: %v\n%s", err, module.String())
+	}
+}

test/goroot/xfail.yaml

@@ -2444,10 +2444,6 @@ xfails:
     directive: run
     case: nilptr2.go
     reason: address-of a dereferenced nil pointer does not panic and the run hangs on darwin/arm64
-  - platform: darwin/arm64
-    directive: run
-    case: range4.go
-    reason: range-over-function build exits successfully without producing a binary on darwin/arm64
   - platform: darwin/arm64
     directive: run
     case: fixedbugs/issue31546.go