[StatementSwitchToExpressionSwitch] Bugfix scenario where local var…

…s take on intersection types, which are not supported for hoisting

PiperOrigin-RevId: 731022030

core/src/main/java/com/google/errorprone/bugpatterns/StatementSwitchToExpressionSwitch.java

@@ -97,6 +97,7 @@
 import java.util.stream.Stream;
 import javax.inject.Inject;
 import javax.lang.model.element.ElementKind;
+import javax.lang.model.type.IntersectionType;
 
 /** Checks for statement switches that can be expressed as an equivalent expression switch. */
 @BugPattern(
@@ -375,8 +376,14 @@ && isSwitchExhaustiveWithoutDefault(
             && exhaustive;
     boolean canConvertDirectlyToExpressionSwitch =
         allCasesHaveDefiniteControlFlow
+            // Hoisting currently not supported for arrays due to restrictions on using assignment
+            // expressions to initialize them
             && symbolsToHoist.keySet().stream()
-                .noneMatch(symbol -> state.getTypes().isArray(symbol.type));
+                .noneMatch(symbol -> state.getTypes().isArray(symbol.type))
+            // Hoisting currently not supported for intersection types because the type is not
+            // denotable as an explicit type (see JLS 21 § 14.4.1.)
+            && symbolsToHoist.keySet().stream()
+                .noneMatch(symbol -> symbol.type instanceof IntersectionType);
 
     List<StatementTree> precedingStatements = getPrecedingStatementsInBlock(switchTree, state);
     Optional<ExpressionTree> assignmentTarget =

core/src/test/java/com/google/errorprone/bugpatterns/StatementSwitchToExpressionSwitchTest.java

@@ -5760,6 +5760,99 @@ public int[] foo() {
         .doTest();
   }
 
+  @Test
+  public void directConversion_hoistIntersectionType_noError() {
+    // The type of foo is an intersection type, which is not supported for hoisting.
+    helper
+        .addSourceLines(
+            "Test.java",
+            """
+            class Test {
+
+              int[] x;
+
+              public Test(int foo) {
+                x = null;
+              }
+
+              public int[] foo() {
+                int z = 1;
+                switch (z) {
+                  case 1:
+                    var foo = (CharSequence & Comparable<String>) "hello";
+                    break;
+                  case 2:
+                    foo = "there";
+                }
+                return x;
+              }
+            }
+            """)
+        .setArgs("-XepOpt:StatementSwitchToExpressionSwitch:EnableDirectConversion")
+        .doTest();
+  }
+
+  @Test
+  public void directConversion_typeParameterWithIntersection_error() {
+    // Type parameters containing type intersections are supported for hoisting.
+    refactoringHelper
+        .addInputLines(
+            "Test.java",
+            """
+            class Test {
+
+              int[] x;
+
+              public Test(int foo) {
+                x = null;
+              }
+
+              public static <T extends CharSequence & Comparable<String>> int[] foo() {
+                int z = 1;
+                switch (z) {
+                  case 1:
+                    T foo = null;
+                    break;
+                  case 2:
+                    System.out.println("Somehow, z was 2.");
+                    foo = null;
+                }
+                return new int[0];
+              }
+            }
+            """)
+        .addOutputLines(
+            "Test.java",
+            """
+            class Test {
+
+              int[] x;
+
+              public Test(int foo) {
+              x = null;
+              }
+
+              public static <T extends CharSequence & Comparable<String>> int[] foo() {
+                int z = 1;
+                T foo;
+                switch(z) {
+                  case 1 -> {
+                    foo = null;
+                  }
+                  case 2 -> {
+                    System.out.println("Somehow, z was 2.");
+                    foo = null;
+                  }
+                }
+                return new int[0];
+              }
+            }
+            """)
+        .setArgs("-XepOpt:StatementSwitchToExpressionSwitch:EnableDirectConversion")
+        .setFixChooser(StatementSwitchToExpressionSwitchTest::assertOneFixAndChoose)
+        .doTest(BugCheckerRefactoringTestHelper.TestMode.TEXT_MATCH);
+  }
+
   @Test
   public void directConversion_lexicalScopeOverlap3_error() {
     // Switch statement is in a labeled statement.  The checker must surround the switch statement