Write literals, catches and && chains as the parser builds them

New rewriteRun checks in rewrite-test fail tests of eight recipes here. One check prints a recipe's output, parses it again and compares the trees. A recipe that runs later matches the tree, not the text, so it misses or mistakes a node that parsed code never holds. Another check fails a template that names a type it doesn't declare.

- ReplaceTextBlockWithString put the two characters `\n` in a literal's value instead of a newline. The value now holds the newline. The text now escapes backslashes, quotes and line breaks, so a text block holding `\\` no longer comes out as an invalid escape.
- IndexOfShouldNotCompareGreaterThanZero changed the text `0` to `1` but kept the value 0.
- NewStringBuilderBufferWithCharArgument and PrimitiveWrapperClassConstructorToValueOf turned a char or double literal into a string and kept the old value. NewStringBuilderBufferWithCharArgument also wrote `'"'` as `"""` and `'\''` as `"\""`. It now keeps the character as written and escapes a double quote.
- CombineSemanticallyEqualCatchBlocks kept a multi-catch with one type when only one type was left. It now catches that type on its own.
- CollapsibleIfStatements built `a && (b && c)` where the parser reads `a && b && c` as `(a && b) && c`. It now groups the merged condition from the left.
- RemoveInstanceOfPatternMatch's template named the instanceof type, such as `LocalDate`, without declaring it. It resolved only through the file's imports. The template now imports the types it names.
- UseTryWithResources named an unused resource `_` on Java 21. Unnamed variables are a preview in Java 21, and javac 21 rejects the code without `--enable-preview`. The recipe now does this from Java 22, as rewrite-migrate-java's ReplaceUnusedVariablesWithUnderscore does. The tests now expect `_` on Java 22 and the old name on Java 21.

Author: jkschneider

src/main/java/org/openrewrite/staticanalysis/CollapsibleIfStatements.java

@@ -81,11 +81,7 @@ public J visitIf(J.If if_, ExecutionContext ctx) {
                     innerCond = wrapInParens(innerCond);
                 }
 
-                Expression combined = JavaElementFactory.newLogicalExpression(
-                        J.Binary.Type.And,
-                        outerCond,
-                        innerCond.withPrefix(Space.SINGLE_SPACE)
-                );
+                Expression combined = and(outerCond, innerCond.withPrefix(Space.SINGLE_SPACE));
 
                 J.If merged = outerIf
                         .withIfCondition(outerIf.getIfCondition().withTree(combined))
@@ -94,6 +90,18 @@ public J visitIf(J.If if_, ExecutionContext ctx) {
                 return autoFormat(merged, ctx);
             }
 
+            /**
+             * Joins two conditions with {@code &&}, grouped from the left as the parser reads {@code a && b && c}.
+             */
+            private Expression and(Expression left, Expression right) {
+                if (right instanceof J.Binary && ((J.Binary) right).getOperator() == J.Binary.Type.And) {
+                    J.Binary binary = (J.Binary) right;
+                    return binary.withLeft(and(left, binary.getLeft().withPrefix(binary.getPrefix())))
+                            .withPrefix(Space.EMPTY);
+                }
+                return JavaElementFactory.newLogicalExpression(J.Binary.Type.And, left, right);
+            }
+
             private Expression wrapInParens(Expression expr) {
                 return new J.Parentheses<>(
                         Tree.randomId(),

src/main/java/org/openrewrite/staticanalysis/CombineSemanticallyEqualCatchBlocks.java

@@ -180,6 +180,10 @@ public J visitMultiCatch(J.MultiCatch multiCatch, ExecutionContext ctx) {
                     J.Try.Catch parent = parentCursor.getValue();
                     if (parent == scope) {
                         List<JRightPadded<NameTree>> combinedCatches = combineEquivalentCatches();
+                        TypeTree onlyType = onlyType(combinedCatches);
+                        if (onlyType != null) {
+                            return onlyType.withPrefix(m.getPrefix());
+                        }
                         m = maybeAutoFormat(m, m.getPadding().withAlternatives(combinedCatches), ctx);
                     }
                 }
@@ -192,15 +196,25 @@ public J visitCatch(J.Try.Catch _catch, ExecutionContext ctx) {
                 if (c == scope && !(c.getParameter().getTree().getTypeExpression() instanceof J.MultiCatch)) {
                     if (c.getParameter().getTree().getTypeExpression() != null) {
                         List<JRightPadded<NameTree>> combinedCatches = combineEquivalentCatches();
+                        TypeTree onlyType = onlyType(combinedCatches);
                         c = maybeAutoFormat(c, c.withParameter(c.getParameter()
                                 .withTree(c.getParameter().getTree()
-                                        .withTypeExpression(new J.MultiCatch(Tree.randomId(), EMPTY, Markers.EMPTY, combinedCatches)))),
+                                        .withTypeExpression(onlyType != null ? onlyType :
+                                                new J.MultiCatch(Tree.randomId(), EMPTY, Markers.EMPTY, combinedCatches)))),
                                 ctx);
                     }
                 }
                 return c;
             }
 
+            /**
+             * The one type left to catch, which the parser makes a plain type rather than a multi-catch, or null.
+             */
+            private static @Nullable TypeTree onlyType(List<JRightPadded<NameTree>> combinedCatches) {
+                return combinedCatches.size() == 1 && combinedCatches.get(0).getElement() instanceof TypeTree ?
+                        (TypeTree) combinedCatches.get(0).getElement() : null;
+            }
+
             private List<JRightPadded<NameTree>> combineEquivalentCatches() {
                 Set<NameTree> removeExceptions = new HashSet<>();
                 List<JRightPadded<NameTree>> combinedCatches = new ArrayList<>();

src/main/java/org/openrewrite/staticanalysis/IndexOfShouldNotCompareGreaterThanZero.java

@@ -60,7 +60,7 @@ public J.Binary visitBinary(J.Binary binary, ExecutionContext ctx) {
                                 J.MethodInvocation mi = (J.MethodInvocation) b.getLeft();
                                 if (STRING_INDEX_MATCHER.matches(mi) || LIST_INDEX_MATCHER.matches(mi)) {
                                     if (b.getRight() instanceof J.Literal && "0".equals(((J.Literal) b.getRight()).getValueSource())) {
-                                        b = b.withRight(((J.Literal) b.getRight()).withValueSource("1")).withOperator(J.Binary.Type.GreaterThanOrEqual);
+                                        b = b.withRight(((J.Literal) b.getRight()).withValue(1).withValueSource("1")).withOperator(J.Binary.Type.GreaterThanOrEqual);
                                     }
                                 }
                             }

src/main/java/org/openrewrite/staticanalysis/NewStringBuilderBufferWithCharArgument.java

@@ -60,9 +60,11 @@ public J.NewClass visitNewClass(J.NewClass newClass, ExecutionContext ctx) {
                         nc = nc.withArguments(ListUtils.mapFirst(nc.getArguments(), arg -> {
                             if (arg instanceof J.Literal) {
                                 J.Literal l = (J.Literal) arg;
-                                l = l.withType(JavaType.buildType("String"));
+                                l = l.withType(JavaType.buildType("String")).withValue(String.valueOf(l.getValue()));
                                 if (l.getValueSource() != null) {
-                                    l = l.withValueSource(l.getValueSource().replace("'", "\""));
+                                    // the character as written, which a string holds as is, except a double quote
+                                    String character = l.getValueSource().substring(1, l.getValueSource().length() - 1);
+                                    l = l.withValueSource("\"" + ("\"".equals(character) ? "\\\"" : character) + "\"");
                                 }
                                 return l;
                             }

src/main/java/org/openrewrite/staticanalysis/PrimitiveWrapperClassConstructorToValueOf.java

@@ -92,8 +92,9 @@ public J visitNewClass(J.NewClass newClass, ExecutionContext ctx) {
                             break;
                         case "java.lang.Float":
                             if (arg instanceof J.Literal && JavaType.Primitive.Double == ((J.Literal) arg).getType()) {
-                                arg = ((J.Literal) arg).withType(JavaType.Primitive.String);
-                                arg = ((J.Literal) arg).withValueSource("\"" + ((J.Literal) arg).getValue() + "\"");
+                                String value = String.valueOf(((J.Literal) arg).getValue());
+                                arg = ((J.Literal) arg).withType(JavaType.Primitive.String).withValue(value)
+                                        .withValueSource("\"" + value + "\"");
                             }
 
                             JavaType argType = arg.getType();

src/main/java/org/openrewrite/staticanalysis/RemoveInstanceOfPatternMatch.java

@@ -194,13 +194,43 @@ private J.Block addVariableDeclaration(Cursor blockCursor, J.InstanceOf instance
             JavaTemplate template = JavaTemplate
                     .builder("#{} #{} = (#{}) #{any()};")
                     .contextSensitive()
+                    .imports(typesNamedBy(instanceOf.getClazz()))
                     .build();
             return template.apply(blockCursor, block.getCoordinates().firstStatement(), instanceOf.getClazz().toString(),
                     ((J.Identifier) Objects.requireNonNull(instanceOf.getPattern())).getSimpleName(),
                     instanceOf.getClazz().toString(),
                     visit(instanceOf.getExpression(), ctx));
         }
 
+        /**
+         * The fully qualified names of the top-level types a type tree names by their simple names.
+         *
+         * @param typeTree the type tree
+         * @return the names for the template to import
+         */
+        private static String[] typesNamedBy(J typeTree) {
+            Set<String> types = new LinkedHashSet<>();
+            new JavaIsoVisitor<Set<String>>() {
+                @Override
+                public J.FieldAccess visitFieldAccess(J.FieldAccess fieldAccess, Set<String> t) {
+                    // a qualified name is found through its first part
+                    visit(fieldAccess.getTarget(), t);
+                    return fieldAccess;
+                }
+
+                @Override
+                public J.Identifier visitIdentifier(J.Identifier identifier, Set<String> t) {
+                    JavaType.FullyQualified type = TypeUtils.asFullyQualified(identifier.getType());
+                    if (type != null && !type.getPackageName().isEmpty() &&
+                            identifier.getSimpleName().equals(type.getClassName())) {
+                        t.add(type.getFullyQualifiedName());
+                    }
+                    return identifier;
+                }
+            }.visit(typeTree, types);
+            return types.toArray(new String[0]);
+        }
+
         /**
          * Creates a type cast expression.
          *

src/main/java/org/openrewrite/staticanalysis/ReplaceTextBlockWithString.java

@@ -65,7 +65,7 @@ public TreeVisitor<?, ExecutionContext> getVisitor() {
                     boolean lastLineIsEmpty = lines[lines.length - 1].isEmpty();
                     int n = lastLineIsEmpty && lines.length == 1 ? 1 : lines.length - 1;
                     for (int i = 0; i < n; i++) {
-                        lines[i] += "\\n";
+                        lines[i] += "\n";
                     }
                     // Take all lines except the last one if it's empty
                     // If there is only one line and it's empty, take it as well
@@ -97,7 +97,8 @@ private J.Literal toLiteral(String str) {
             }
 
             private String quote(String str) {
-                return "\"" + str.replace("\"", "\\\"") + "\"";
+                return "\"" + str.replace("\\", "\\\\").replace("\"", "\\\"")
+                        .replace("\n", "\\n").replace("\r", "\\r") + "\"";
             }
         });
     }

src/main/java/org/openrewrite/staticanalysis/UseTryWithResources.java

@@ -71,7 +71,7 @@ public J.Block visitBlock(J.Block block, ExecutionContext ctx) {
                         List<Statement> stmts = b.getStatements();
                         boolean unnamedAvailable = getCursor().firstEnclosingOrThrow(JavaSourceFile.class)
                                 .getMarkers().findFirst(JavaVersion.class)
-                                .filter(v -> v.getMajorVersion() >= 21)
+                                .filter(v -> v.getMajorVersion() >= 22)
                                 .isPresent();
                         return b.withStatements(ListUtils.map(stmts, (i, stmt) -> {
                             if (stmt instanceof J.Try) {
@@ -177,7 +177,7 @@ private static J.Try transform(J.VariableDeclarations varDecl, J.Try tryStmt, bo
         String varName = varDecl.getVariables().get(0).getSimpleName();
         J.VariableDeclarations resourceDecl = varDecl.withPrefix(Space.EMPTY);
         // When the resource is never read inside the try body, name it with the unnamed variable `_`
-        // (JEP 443 preview in Java 21, finalized as JEP 456 in Java 22) so the rewritten code does
+        // (JEP 456 in Java 22, a preview in Java 21 that needs --enable-preview) so the rewritten code does
         // not emit an unused-variable warning that would fail `-Werror` builds.
         if (unnamedAvailable && !isReferenced(varName, tryStmt.getBody())) {
             J.VariableDeclarations.NamedVariable namedVar = resourceDecl.getVariables().get(0);

src/test/java/org/openrewrite/staticanalysis/CombineSemanticallyEqualCatchBlocksTest.java

@@ -433,6 +433,40 @@ void method() {
         );
     }
 
+    @Test
+    void removeRedundantChildClassesOfMultiCatch() {
+        rewriteRun(
+          //language=java
+          java("class A extends BaseException {}"),
+          //language=java
+          java("class B extends BaseException {}"),
+          //language=java
+          java("class BaseException extends RuntimeException {}"),
+          //language=java
+          java(
+            """
+              class Test {
+                  void method() {
+                      try {
+                      } catch (A | B ex) {
+                      } catch (BaseException ex) {
+                      }
+                  }
+              }
+              """,
+            """
+              class Test {
+                  void method() {
+                      try {
+                      } catch (BaseException ex) {
+                      }
+                  }
+              }
+              """
+          )
+        );
+    }
+
     @Test
     void dontCombineCatchBlocksWithDifferentMethodInvocationParameters() {
         rewriteRun(

src/test/java/org/openrewrite/staticanalysis/NewStringBuilderBufferWithCharArgumentTest.java

@@ -55,6 +55,28 @@ class A {
         );
     }
 
+    @SuppressWarnings("NewStringBufferWithCharArgument")
+    @Test
+    void quoteCharacters() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              class A {
+                  StringBuilder doubleQuote = new StringBuilder('"');
+                  StringBuilder singleQuote = new StringBuilder('\\'');
+              }
+              """,
+            """
+              class A {
+                  StringBuilder doubleQuote = new StringBuilder("\\"");
+                  StringBuilder singleQuote = new StringBuilder("\\'");
+              }
+              """
+          )
+        );
+    }
+
     @Test
     void validStringArg() {
         rewriteRun(