Merge branch 'main' into remove-private-field-underscores

Author: greg-at-moderne

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

@@ -112,6 +112,21 @@ public J visitTypeCast(J.TypeCast typeCast, ExecutionContext ctx) {
                     return visitedTypeCast;
                 }
 
+                // Special case: if this cast is in a generic method call that's part of a method chain,
+                // the cast might be necessary to control generic type inference
+                if (parentValue instanceof J.MethodInvocation &&
+                        TypeUtils.isAssignableTo(castType, expressionType) &&
+                        !castType.equals(expressionType)) {
+                    // Check if the method returns a generic type
+                    JavaType.Method methodType = ((J.MethodInvocation) parentValue).getMethodType();
+                    if (methodType != null && methodType.getReturnType() instanceof JavaType.Parameterized) {
+                        // This cast is widening the type (e.g., BarImpl to Bar) in a generic context
+                        // which might affect how the generic type is inferred in method chains
+                        // Keep the cast to be safe
+                        return visitedTypeCast;
+                    }
+                }
+
                 if (!(targetType instanceof JavaType.Array) && TypeUtils.isOfClassType(targetType, "java.lang.Object") ||
                     TypeUtils.isOfType(targetType, expressionType) ||
                     TypeUtils.isAssignableTo(targetType, expressionType)) {

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

@@ -48,6 +48,11 @@ public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, Execu
                 }
 
                 Object enclosing = getCursor().getParentTreeCursor().getValue();
+
+                if (enclosing instanceof J.Ternary) {
+                    return m; // may be necessary for type inference
+                }
+
                 JavaType inferredType = null;
                 if (enclosing instanceof J.MethodInvocation) {
                     if (shouldRetainOnStaticMethod(methodType)) {

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

@@ -103,6 +103,46 @@ List<String> testLambda(List<String> names) {
         );
     }
 
+    @Test
+    void inlineSwitch() {
+        rewriteRun(
+          //language=java
+          java(
+            """
+              import java.util.List;
+              import java.util.stream.Collectors;
+
+              class Test {
+                  String test(int n) {
+                      String s = switch (n) {
+                          case 1 -> "one";
+                          case 2 -> "two";
+                          case 3 -> "three";
+                          default -> "unknown";
+                      };
+                      return s;
+                  }
+              }
+              """,
+            """
+              import java.util.List;
+              import java.util.stream.Collectors;
+
+              class Test {
+                  String test(int n) {
+                      return switch (n) {
+                          case 1 -> "one";
+                          case 2 -> "two";
+                          case 3 -> "three";
+                          default -> "unknown";
+                      };
+                  }
+              }
+              """
+          )
+        );
+    }
+
     @SuppressWarnings("UnnecessaryLocalVariable")
     @Test
     void preserveComments() {

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

@@ -528,4 +528,32 @@ void bar(Marshaller marshaller) {
           )
         );
     }
+
+    @Test
+    void dontRemoveNecessaryDowncast() {
+        rewriteRun(
+          // language=java
+          java(
+            """
+              import java.util.Optional;
+
+              interface Bar {}
+              class BarImpl implements Bar {}
+              class Foo {
+                  private Bar getBar() {
+                      return new BarImpl();
+                  }
+
+                  private BarImpl getBarImpl() {
+                      return new BarImpl();
+                  }
+
+                  public Bar baz() {
+                   return Optional.of((Bar) getBarImpl()).orElse(getBar());
+                 }
+              }
+              """
+          )
+        );
+    }
 }

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

@@ -139,7 +139,6 @@ void test() {
         );
     }
 
-    @ExpectedToFail
     @Issue("https://github.com/openrewrite/rewrite-static-analysis/issues/164")
     @Test
     void doesNotRemoveNecessaryTypeArguments() {
@@ -150,8 +149,8 @@ void doesNotRemoveNecessaryTypeArguments() {
               import java.util.Optional;
               import java.util.stream.Stream;
               public class Test {
-                  void test() {
-                      Stream.of("hi")
+                  void test(String s) {
+                      Stream.of(s)
                               .map(it -> it == null ? Optional.<String>empty() : Optional.of(it))
                               .flatMap(Optional::stream)
                               .map(this::mapper); //this requires the type information