Fix context-sensitive template replacement for standalone expression statements in non-void methods (#7211)

When a JavaTemplate replaces a standalone method invocation expression statement
inside a non-void method, the generated template stub was missing a semicolon
after the expression. The semicolon was appended to the `after` buffer after
the `}\nreturn ...;` from the non-void method wrapping, placing it outside the
`if(true)` block instead of directly after the template content. This caused
`parseBlockStatements` to return 0 results.

Fix by using `insert(0, ';')` instead of `append(';')` so the semicolon is
placed before the closing brace of the `if(true)` block.

Author: timtebeek

rewrite-java-test/src/test/java/org/openrewrite/java/JavaTemplateTest8Test.java

@@ -257,6 +257,83 @@ public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, Ex
         );
     }
 
+    @Test
+    void replaceContextSensitiveMethodInvocationStandaloneStatement() {
+        rewriteRun(
+          spec -> spec.recipe(toRecipe(() -> new JavaIsoVisitor<>() {
+              @Override
+              public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) {
+                  method = super.visitMethodInvocation(method, ctx);
+                  if (method.getSimpleName().equals("visitClassDeclaration") &&
+                      method.getSelect() != null &&
+                      !(method.getSelect() instanceof J.Identifier &&
+                        "super".equals(((J.Identifier) method.getSelect()).getSimpleName()))) {
+                      return JavaTemplate.builder("#{any()}.visit(#{any()}, #{any()}, getCursor().getParentTreeCursor())")
+                        .contextSensitive()
+                        .javaParser(JavaParser.fromJavaVersion().classpath(JavaParser.runtimeClasspath()))
+                        .build()
+                        .apply(getCursor(), method.getCoordinates().replace(),
+                          method.getSelect(), method.getArguments().get(0), method.getArguments().get(1));
+                  }
+                  return method;
+              }
+          })),
+          java(
+            """
+              import org.openrewrite.*;
+              import org.openrewrite.java.JavaIsoVisitor;
+              import org.openrewrite.java.JavaVisitor;
+              import org.openrewrite.java.tree.J;
+
+              class MyRecipe extends Recipe {
+                  @Override
+                  public String getDisplayName() { return ""; }
+                  @Override
+                  public String getDescription() { return ""; }
+
+                  @Override
+                  public TreeVisitor<?, ExecutionContext> getVisitor() {
+                      return new JavaIsoVisitor<ExecutionContext>() {
+                          @Override
+                          public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext ctx) {
+                              J.ClassDeclaration cd = super.visitClassDeclaration(classDecl, ctx);
+                              new JavaVisitor<ExecutionContext>() {}.visitClassDeclaration(cd, ctx);
+                              return cd;
+                          }
+                      };
+                  }
+              }
+              """,
+            """
+              import org.openrewrite.*;
+              import org.openrewrite.java.JavaIsoVisitor;
+              import org.openrewrite.java.JavaVisitor;
+              import org.openrewrite.java.tree.J;
+
+              class MyRecipe extends Recipe {
+                  @Override
+                  public String getDisplayName() { return ""; }
+                  @Override
+                  public String getDescription() { return ""; }
+
+                  @Override
+                  public TreeVisitor<?, ExecutionContext> getVisitor() {
+                      return new JavaIsoVisitor<ExecutionContext>() {
+                          @Override
+                          public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext ctx) {
+                              J.ClassDeclaration cd = super.visitClassDeclaration(classDecl, ctx);
+                              new JavaVisitor<ExecutionContext>() {
+                              }.visit(cd, ctx, getCursor().getParentTreeCursor());
+                              return cd;
+                          }
+                      };
+                  }
+              }
+              """
+          )
+        );
+    }
+
     @DocumentExample
     @Test
     void parameterizedMatch() {

rewrite-java/src/main/java/org/openrewrite/java/internal/template/BlockStatementTemplateGenerator.java

@@ -321,8 +321,9 @@ private void contextTemplate(Cursor cursor, J prior, StringBuilder before, Strin
             }
 
             if (prior == insertionPoint && prior instanceof Expression) {
-                // the template represents an expression, so we need to wrap it in a statement
-                after.append(';');
+                // the template represents an expression, so we need to wrap it in a statement.
+                // Use insert(0, ...) so the semicolon comes before any "}\nreturn ...;" from non-void methods.
+                after.insert(0, ';');
             }
             after.append('}');
         } else if (j instanceof J.Annotation) {