Kotlin: declare caller-scope type variables on synthetic Template class (#7414)

* Kotlin: declare caller-scope type variables on synthetic Template class

The Kotlin `BlockStatementTemplateGenerator` ignored the `typeVariables`
collected from parameter types, emitting a bare `class Template {`. When a
template parameter's type referenced a caller-scope generic (e.g.
`Container<T>` from an enclosing `fun <T : Any> ...`), the substitution
produced `__P__.p<Container<T>>()` inside a class where `T` was undeclared.

Now the Kotlin generator declares those type variables using Kotlin
syntax (`T : Bound` for a single bound, `where` clause for multiple).

Fixes #7407

* Kotlin: extract type parameter string helper to KotlinTypeUtils

* Kotlin: inline type parameter helper into template generator

Author: timtebeek

rewrite-kotlin/src/main/java/org/openrewrite/kotlin/internal/template/KotlinBlockStatementTemplateGenerator.java

@@ -21,9 +21,11 @@
 import org.openrewrite.java.tree.J;
 import org.openrewrite.java.tree.JavaType;
 import org.openrewrite.java.tree.Statement;
+import org.openrewrite.java.tree.TypeUtils;
 import org.openrewrite.kotlin.tree.K;
 
 import java.util.Collection;
+import java.util.List;
 import java.util.Set;
 
 public class KotlinBlockStatementTemplateGenerator extends BlockStatementTemplateGenerator {
@@ -33,16 +35,17 @@ public KotlinBlockStatementTemplateGenerator(Set<String> imports, boolean contex
 
     @Override
     protected void contextFreeTemplate(Cursor cursor, J j, Collection<JavaType.GenericTypeVariable> typeVariables, StringBuilder before, StringBuilder after) {
+        String classDeclaration = "class Template" + kotlinTypeParameters(typeVariables);
         if (j instanceof Expression && !(j instanceof J.Assignment)) {
-            before.insert(0, "class Template {\n");
+            before.insert(0, classDeclaration + " {\n");
             before.append("var o : Any = ");
             after.append(";\n}");
         } else if (j instanceof J.ClassDeclaration || j instanceof K.ClassDeclaration) {
             throw new IllegalArgumentException(
                     "Templating a class declaration requires context from which package declaration and imports may be reached. " +
                     "Mark this template as context-sensitive by calling KotlinTemplate.Builder#contextSensitive().");
         } else if (j instanceof Statement && !(j instanceof J.Import) && !(j instanceof J.Package)) {
-            before.insert(0, "class Template {\ninit {\n");
+            before.insert(0, classDeclaration + " {\ninit {\n");
             after.append("\n}\n}");
         } else {
             throw new IllegalArgumentException(
@@ -54,4 +57,44 @@ protected void contextFreeTemplate(Cursor cursor, J j, Collection<JavaType.Gener
             before.insert(0, anImport);
         }
     }
+
+    private static String kotlinTypeParameters(Collection<JavaType.GenericTypeVariable> typeVariables) {
+        if (typeVariables.isEmpty()) {
+            return "";
+        }
+        StringBuilder params = new StringBuilder("<");
+        StringBuilder where = new StringBuilder();
+        boolean firstParam = true;
+        for (JavaType.GenericTypeVariable tv : typeVariables) {
+            if ("?".equals(tv.getName())) {
+                continue;
+            }
+            if (!firstParam) {
+                params.append(", ");
+            }
+            firstParam = false;
+            params.append(tv.getName());
+            List<JavaType> bounds = tv.getBounds();
+            if (tv.getVariance() == JavaType.GenericTypeVariable.Variance.COVARIANT && !bounds.isEmpty()) {
+                if (bounds.size() == 1) {
+                    params.append(" : ").append(TypeUtils.toString(bounds.get(0)));
+                } else {
+                    for (JavaType bound : bounds) {
+                        if (where.length() > 0) {
+                            where.append(", ");
+                        }
+                        where.append(tv.getName()).append(" : ").append(TypeUtils.toString(bound));
+                    }
+                }
+            }
+        }
+        if (firstParam) {
+            return "";
+        }
+        params.append(">");
+        if (where.length() > 0) {
+            params.append(" where ").append(where);
+        }
+        return params.toString();
+    }
 }

rewrite-kotlin/src/test/java/org/openrewrite/kotlin/KotlinTemplateTest.java

@@ -19,13 +19,15 @@
 import org.junit.jupiter.api.Test;
 import org.openrewrite.DocumentExample;
 import org.openrewrite.ExecutionContext;
-import org.openrewrite.java.tree.J;
-import org.openrewrite.test.RewriteTest;
-
+import org.openrewrite.Issue;
 import org.openrewrite.java.JavaTemplate;
+import org.openrewrite.java.tree.J;
 import org.openrewrite.java.tree.Statement;
+import org.openrewrite.test.RewriteTest;
 import org.openrewrite.test.TypeValidation;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 import java.net.URISyntaxException;
 import java.nio.file.Path;
 import java.util.List;
@@ -170,7 +172,7 @@ fun foo() {
               """,
             """
               import com.fasterxml.jackson.databind.ObjectMapper
-              
+
               class Test {
                   fun foo() {
                       val mapper = ObjectMapper()
@@ -179,4 +181,40 @@ fun foo() {
               """
           ));
     }
+
+    @Issue("https://github.com/openrewrite/rewrite/issues/7407")
+    @Test
+    void parameterTypeWithCallerScopeTypeVariable() {
+        StringBuilder capturedTemplate = new StringBuilder();
+        rewriteRun(
+          spec -> spec.typeValidationOptions(TypeValidation.builder().methodInvocations(false).build()).recipe(toRecipe(() -> new KotlinVisitor<>() {
+              @Override
+              public J visitVariableDeclarations(J.VariableDeclarations multiVariable, ExecutionContext ctx) {
+                  if (multiVariable.getVariables().size() == 1 &&
+                      "x".equals(multiVariable.getVariables().getFirst().getSimpleName())) {
+                      J initializer = multiVariable.getVariables().getFirst().getInitializer();
+                      return KotlinTemplate.builder("println(#{any()})")
+                        .doBeforeParseTemplate(capturedTemplate::append)
+                        .build()
+                        .apply(getCursor(), multiVariable.getCoordinates().replace(), initializer);
+                  }
+                  return super.visitVariableDeclarations(multiVariable, ctx);
+              }
+          }).withMaxCycles(1)),
+          kotlin(
+            """
+              class Container<T : Any>(val value: T)
+              fun <T : Any> test(c: Container<T>) {
+                  val x = c
+              }
+              """,
+            """
+              class Container<T : Any>(val value: T)
+              fun <T : Any> test(c: Container<T>) {
+                  println(c)
+              }
+              """
+          ));
+        assertThat(capturedTemplate.toString()).contains("class Template<T");
+    }
 }