Go: add StatementExpression, fix variadic params, remove receiver overrides (#7261)

* Revert "Go: override Java receiver visitors for Go-specific type mismatches (#7258)"

This reverts commit 8174845.

* Go: add StatementExpression for func literals, fix variadic params and parse input order

Add Go.StatementExpression (both Java and Go sides) to wrap
MethodDeclaration in expression contexts, following the same pattern
as Cs.StatementExpression in rewrite-csharp. Func literals like
`func(x int) int { return x }` are parsed as MethodDeclaration (a
Statement) but need to appear in returns, assignments, and call args.

Fix variadic parameter handling: detect `...T` in mapFieldListAsParams,
store the `...` prefix in VariableDeclarations.Varargs, and pass only
the element type through mapTypeExpr. Previously `...T` was mapped as
Unary{Spread, T} in the TypeExpr field, which violated the TypeTree
constraint.

Fix RPC parse input order: check Text before Path/SourcePath so text-
based inputs (from integration tests) aren't mistakenly treated as
file paths.

Add 8 integration tests. 51 of 52 pass (goroutineAndDefer fails due
to directly-invoked func literal `go func(){}()` padding mismatch).

Author: jkschneider

rewrite-go/rewrite/cmd/rpc/main.go

@@ -308,11 +308,22 @@ func (s *server) handleParse(params json.RawMessage) (any, *rpcError) {
 		var sourcePath string
 		var source string
 
-		filePath := input.Path
-		if filePath == "" {
-			filePath = input.SourcePath
-		}
-		if filePath != "" {
+		if input.Text != "" {
+			// Text-based input (inline source from tests or recipe framework)
+			source = input.Text
+			sourcePath = input.SourcePath
+			if sourcePath == "" {
+				sourcePath = "<unknown>"
+			}
+		} else {
+			// File-path-based input (mod build sends file paths)
+			filePath := input.Path
+			if filePath == "" {
+				filePath = input.SourcePath
+			}
+			if filePath == "" {
+				continue
+			}
 			absPath := filePath
 			data, err := os.ReadFile(absPath)
 			if err != nil {
@@ -329,14 +340,6 @@ func (s *server) handleParse(params json.RawMessage) (any, *rpcError) {
 			} else {
 				sourcePath = absPath
 			}
-		} else if input.Text != "" {
-			source = input.Text
-			sourcePath = input.SourcePath
-			if sourcePath == "" {
-				sourcePath = "<unknown>"
-			}
-		} else {
-			continue
 		}
 
 		cu, parseErr := func() (cu *tree.CompilationUnit, err error) {

rewrite-go/rewrite/pkg/parser/go_parser.go

@@ -1970,14 +1970,21 @@ func (ctx *parseContext) mapFuncLit(expr *ast.FuncLit) tree.Expression {
 	returnType := ctx.mapReturnType(expr.Type.Results)
 	body := ctx.mapBlockStmt(expr.Body)
 
-	return &tree.MethodDeclaration{
+	md := &tree.MethodDeclaration{
 		ID:         uuid.New(),
-		Prefix:     prefix,
 		Name:       &tree.Identifier{ID: uuid.New(), Name: ""},
 		Parameters: params,
 		ReturnType: returnType,
 		Body:       body,
 	}
+	// Wrap in StatementExpression so the MethodDeclaration (a Statement) can
+	// appear in expression contexts like return statements, assignments, and
+	// call arguments.
+	return &tree.StatementExpression{
+		ID:        uuid.New(),
+		Prefix:    prefix,
+		Statement: md,
+	}
 }
 
 // mapKeyValueExpr maps a key:value expression in composite literals.

rewrite-go/rewrite/pkg/printer/go_printer.go

@@ -751,6 +751,14 @@ func (p *GoPrinter) VisitMapType(mt *tree.MapType, param any) tree.J {
 	return mt
 }
 
+func (p *GoPrinter) VisitStatementExpression(se *tree.StatementExpression, param any) tree.J {
+	out := param.(*PrintOutputCapture)
+	p.beforeSyntax(se.Prefix, se.Markers, out)
+	p.Visit(se.Statement, out)
+	p.afterSyntax(se.Markers, out)
+	return se
+}
+
 func (p *GoPrinter) VisitPointerType(pt *tree.PointerType, param any) tree.J {
 	out := param.(*PrintOutputCapture)
 	p.beforeSyntax(pt.Prefix, pt.Markers, out)

rewrite-go/rewrite/pkg/rpc/go_receiver.go

@@ -74,6 +74,8 @@ func (r *GoReceiver) Visit(node any, q *ReceiveQueue) any {
 		return r.receiveSlice(v, q)
 	case *tree.MapType:
 		return r.receiveMapType(v, q)
+	case *tree.StatementExpression:
+		return r.receiveStatementExpression(v, q)
 	case *tree.PointerType:
 		return r.receivePointerType(v, q)
 	case *tree.Channel:
@@ -125,6 +127,8 @@ func (r *GoReceiver) preVisit(node any, q *ReceiveQueue) any {
 		c := *n; node = &c
 	case *tree.MapType:
 		c := *n; node = &c
+	case *tree.StatementExpression:
+		c := *n; node = &c
 	case *tree.PointerType:
 		c := *n; node = &c
 	case *tree.Channel:
@@ -404,6 +408,16 @@ func (r *GoReceiver) receiveMapType(mt *tree.MapType, q *ReceiveQueue) *tree.Map
 	return mt
 }
 
+func (r *GoReceiver) receiveStatementExpression(se *tree.StatementExpression, q *ReceiveQueue) *tree.StatementExpression {
+	c := *se
+	se = &c
+	result := q.Receive(se.Statement, func(v any) any { return r.Visit(v, q) })
+	if result != nil {
+		se.Statement = result.(tree.Statement)
+	}
+	return se
+}
+
 func (r *GoReceiver) receivePointerType(pt *tree.PointerType, q *ReceiveQueue) *tree.PointerType {
 	c := *pt
 	pt = &c

rewrite-go/rewrite/pkg/rpc/go_sender.go

@@ -73,6 +73,8 @@ func (s *GoSender) Visit(node any, q *SendQueue) {
 		s.sendSlice(v, q)
 	case *tree.MapType:
 		s.sendMapType(v, q)
+	case *tree.StatementExpression:
+		s.sendStatementExpression(v, q)
 	case *tree.PointerType:
 		s.sendPointerType(v, q)
 	case *tree.Channel:
@@ -211,6 +213,11 @@ func (s *GoSender) sendMapType(mt *tree.MapType, q *SendQueue) {
 		func(v any) { s.Visit(v, q) })
 }
 
+func (s *GoSender) sendStatementExpression(se *tree.StatementExpression, q *SendQueue) {
+	q.GetAndSend(se, func(v any) any { return v.(*tree.StatementExpression).Statement },
+		func(v any) { s.Visit(v, q) })
+}
+
 func (s *GoSender) sendPointerType(pt *tree.PointerType, q *SendQueue) {
 	q.GetAndSend(pt, func(v any) any { return v.(*tree.PointerType).Elem },
 		func(v any) { s.Visit(v, q) })

rewrite-go/rewrite/pkg/rpc/node_helpers.go

@@ -60,6 +60,8 @@ func nodePrefix(v any) any {
 		return n.Prefix
 	case *tree.PointerType:
 		return n.Prefix
+	case *tree.StatementExpression:
+		return n.Prefix
 	case *tree.Channel:
 		return n.Prefix
 	case *tree.FuncType:
@@ -174,6 +176,8 @@ func nodeMarkers(v any) any {
 		return n.Markers
 	case *tree.PointerType:
 		return n.Markers
+	case *tree.StatementExpression:
+		return n.Markers
 	case *tree.Channel:
 		return n.Markers
 	case *tree.FuncType:
@@ -288,6 +292,8 @@ func setPrefix(v any, prefix tree.Space) {
 		n.Prefix = prefix
 	case *tree.PointerType:
 		n.Prefix = prefix
+	case *tree.StatementExpression:
+		n.Prefix = prefix
 	case *tree.Channel:
 		n.Prefix = prefix
 	case *tree.FuncType:
@@ -400,6 +406,8 @@ func setMarkers(v any, markers tree.Markers) {
 		n.Markers = markers
 	case *tree.PointerType:
 		n.Markers = markers
+	case *tree.StatementExpression:
+		n.Markers = markers
 	case *tree.Channel:
 		n.Markers = markers
 	case *tree.FuncType:

rewrite-go/rewrite/pkg/tree/go.go

@@ -564,6 +564,32 @@ func (n *CommClause) WithMarkers(markers Markers) *CommClause {
 	return &c
 }
 
+// StatementExpression wraps a Statement so it can appear in expression contexts.
+// Used for Go function literals which are parsed as MethodDeclaration (a Statement)
+// but can appear in return statements, assignments, and call arguments.
+type StatementExpression struct {
+	ID        uuid.UUID
+	Prefix    Space
+	Markers   Markers
+	Statement Statement
+}
+
+func (*StatementExpression) isTree()       {}
+func (*StatementExpression) isJ()          {}
+func (*StatementExpression) isExpression() {}
+
+func (n *StatementExpression) WithPrefix(prefix Space) *StatementExpression {
+	c := *n
+	c.Prefix = prefix
+	return &c
+}
+
+func (n *StatementExpression) WithMarkers(markers Markers) *StatementExpression {
+	c := *n
+	c.Markers = markers
+	return &c
+}
+
 // IndexList represents a multi-index expression like `Map[int, string]` (generic instantiation
 // with multiple type parameters). Single-index uses ArrayAccess; this is for 2+ indices.
 type IndexList struct {

rewrite-go/rewrite/pkg/visitor/go_visitor.go

@@ -123,6 +123,8 @@ func (v *GoVisitor) Visit(t tree.Tree, p any) tree.Tree {
 		return v.self().VisitSlice(n, p)
 	case *tree.MapType:
 		return v.self().VisitMapType(n, p)
+	case *tree.StatementExpression:
+		return v.self().VisitStatementExpression(n, p)
 	case *tree.PointerType:
 		return v.self().VisitPointerType(n, p)
 	case *tree.Channel:
@@ -200,6 +202,7 @@ type VisitorI interface {
 	VisitKeyValue(kv *tree.KeyValue, p any) tree.J
 	VisitSlice(s *tree.Slice, p any) tree.J
 	VisitMapType(mt *tree.MapType, p any) tree.J
+	VisitStatementExpression(se *tree.StatementExpression, p any) tree.J
 	VisitPointerType(pt *tree.PointerType, p any) tree.J
 	VisitChannel(ch *tree.Channel, p any) tree.J
 	VisitFuncType(ft *tree.FuncType, p any) tree.J
@@ -538,6 +541,16 @@ func (v *GoVisitor) VisitMapType(mt *tree.MapType, p any) tree.J {
 	return mt
 }
 
+func (v *GoVisitor) VisitStatementExpression(se *tree.StatementExpression, p any) tree.J {
+	se = se.WithPrefix(v.self().VisitSpace(se.Prefix, p))
+	se = se.WithMarkers(v.visitMarkers(se.Markers, p))
+	result := v.self().Visit(se.Statement, p)
+	if stmt, ok := result.(tree.Statement); ok {
+		se.Statement = stmt
+	}
+	return se
+}
+
 func (v *GoVisitor) VisitPointerType(pt *tree.PointerType, p any) tree.J {
 	pt = pt.WithPrefix(v.self().VisitSpace(pt.Prefix, p))
 	pt = pt.WithMarkers(v.visitMarkers(pt.Markers, p))

rewrite-go/src/main/java/org/openrewrite/golang/GolangVisitor.java

@@ -155,6 +155,19 @@ public J visitMapType(Go.MapType mapType, P p) {
         return m;
     }
 
+    public J visitStatementExpression(Go.StatementExpression statementExpression, P p) {
+        Go.StatementExpression se = statementExpression;
+        se = se.withPrefix(visitSpace(se.getPrefix(), Space.Location.LANGUAGE_EXTENSION, p));
+        Expression tempExpression = (Expression) visitExpression(se, p);
+        if (!(tempExpression instanceof Go.StatementExpression)) {
+            return tempExpression;
+        }
+        se = (Go.StatementExpression) tempExpression;
+        se = se.withMarkers(visitMarkers(se.getMarkers(), p));
+        se = se.withStatement((Statement) visitAndCast(se.getStatement(), p));
+        return se;
+    }
+
     public J visitPointerType(Go.PointerType pointerType, P p) {
         Go.PointerType pt = pointerType;
         pt = pt.withPrefix(visitSpace(pt.getPrefix(), Space.Location.LANGUAGE_EXTENSION, p));