Handle switches with alternatives.

Author: sjrd

compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala

@@ -770,7 +770,7 @@ object PatternMatcher {
      *  a switch, including a last default case, by starting with this
      *  plan and following onSuccess plans.
      */
-    private def collectSwitchCases(scrutinee: Tree, plan: SeqPlan): List[Plan] = {
+    private def collectSwitchCases(scrutinee: Tree, plan: SeqPlan): List[(List[Tree], Plan)] = {
       def isSwitchableType(tpe: Type): Boolean =
         (tpe isRef defn.IntClass) ||
         (tpe isRef defn.ByteClass) ||
@@ -782,24 +782,68 @@ object PatternMatcher {
         case _ => false
       }
 
-      def recur(plan: Plan): List[Plan] = plan match {
+      object AlternativesPlan {
+        def unapply(plan: LabeledPlan): Option[(List[Tree], Plan)] = {
+          plan.expr match {
+            case SeqPlan(LabeledPlan(innerLabel, innerPlan), ons) =>
+              val outerLabel = plan.sym
+              val alts = List.newBuilder[Tree]
+              def rec(innerPlan: Plan): Boolean = innerPlan match {
+                case SeqPlan(TestPlan(EqualTest(tree), scrut, _, ReturnPlan(`innerLabel`)), tail)
+                if scrut === scrutinee && isIntConst(tree) =>
+                  alts += tree
+                  rec(tail)
+                case ReturnPlan(`outerLabel`) =>
+                  true
+                case _ =>
+                  false
+              }
+              if (rec(innerPlan))
+                Some((alts.result(), ons))
+              else
+                None
+
+            case _ =>
+              None
+          }
+        }
+      }
+
+      def recur(plan: Plan): List[(List[Tree], Plan)] = plan match {
         case SeqPlan(testPlan @ TestPlan(EqualTest(tree), scrut, _, ons), tail)
         if scrut === scrutinee && isIntConst(tree) && !canFallThrough(ons) =>
-          testPlan :: recur(tail)
+          (tree :: Nil, ons) :: recur(tail)
+        case SeqPlan(AlternativesPlan(alts, ons), tail) =>
+          (alts, ons) :: recur(tail)
         case _ =>
-          plan :: Nil
+          (Nil, plan) :: Nil
       }
 
       if (isSwitchableType(scrutinee.tpe.widen)) recur(plan)
       else Nil
     }
 
+    private def hasEnoughSwitchCases(cases: List[(List[Tree], Plan)], required: Int): Boolean = {
+      // 1 because of the default case
+      required <= 1 || {
+        cases match {
+          case (alts, _) :: cases1 => hasEnoughSwitchCases(cases1, required - alts.size)
+          case _ => false
+        }
+      }
+    }
+
     /** Emit cases of a switch */
-    private def emitSwitchCases(cases: List[Plan]): List[CaseDef] = (cases: @unchecked) match {
-      case (default: Plan) :: Nil =>
-        CaseDef(Underscore(defn.IntType), EmptyTree, emit(default)) :: Nil
-      case TestPlan(EqualTest(tree), _, _, ons) :: cases1 =>
-        CaseDef(tree, EmptyTree, emit(ons)) :: emitSwitchCases(cases1)
+    private def emitSwitchCases(cases: List[(List[Tree], Plan)]): List[CaseDef] = (cases: @unchecked) match {
+      case (alts, ons) :: cases1 =>
+        val pat = alts match {
+          case alt :: Nil => alt
+          case Nil => Underscore(defn.IntType) // default case
+          case _ => Alternative(alts)
+        }
+        CaseDef(pat, EmptyTree, emit(ons)) :: emitSwitchCases(cases1)
+      case nil =>
+        Nil
     }
 
     /** If selfCheck is `true`, used to check whether a tree gets generated twice */
@@ -861,7 +905,7 @@ object PatternMatcher {
             case testPlan: TestPlan =>
               val scrutinee = testPlan.scrutinee
               val switchCases = collectSwitchCases(scrutinee, plan)
-              if (switchCases.lengthCompare(MinSwitchCases) >= 0) // at least 3 cases + default
+              if (hasEnoughSwitchCases(switchCases, MinSwitchCases)) // at least 3 cases + default
                 Match(scrutinee, emitSwitchCases(switchCases))
               else
                 default

tests/pos-special/fatal-warnings/switches.scala

@@ -0,0 +1,8 @@
+class Test {
+  def test1(x: Int): Int = (x: @annotation.switch) match {
+    case 1 => 1
+    case 2 | 3 | 4 => 2
+    case 65 => 3
+    case 72 => 4
+  }
+}