Fix pattern matching alternative wip

Author: andrevidela

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

@@ -769,16 +769,31 @@ object PatternMatcher {
     }
 
     /** Emit cases of a switch */
-    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)
+    private def emitSwitchCases(cases: List[(List[Tree], Plan)]): List[CaseDef] = cases.foldLeft(List[CaseDef]()) {
+      case (prev, (alts, ons)) =>
+        val pat = simplifyCases(alts) match {
+          case Alternative(als) =>
+            simplifyCases(removeRedundantCases(prev.map(_.pat), als))
+          case t => t
         }
-        CaseDef(pat, EmptyTree, emit(ons)) :: emitSwitchCases(cases1)
-      case nil =>
-        Nil
+        CaseDef(pat, EmptyTree, emit(ons)) :: prev
+    }
+
+    /** Remove cases that already appear in the same pattern or in previous patterns */
+    private def removeRedundantCases(previousCases: List[Tree], cases: List[Tree]): List[Tree] = cases.foldLeft(List[Tree]()) {
+      case (cases, alt) =>
+        if (cases.exists(_ === alt) || previousCases.exists(_ === alt)) {
+          cases
+        } else {
+          alt :: cases
+        }
+    }
+
+    /** Flatten a list of patterns into a single tree */
+    private def simplifyCases(alts: List[Tree]): Tree = alts match {
+      case alt :: Nil => alt
+      case Nil => Underscore(defn.IntType) // default case
+      case _ => Alternative(alts)
     }
 
     /** If selfCheck is `true`, used to check whether a tree gets generated twice */

tests/pos/patternMatchAlternative.scala

@@ -0,0 +1,23 @@
+
+object Main {
+  val a: Int = 4
+  a match {
+    case 1 => println("1")
+    case 1 | 2 => println("1 or 2")
+  }
+
+  a match {
+    case 1 => 1
+    case 0 | 0 => 0
+    case 2 | 2 | 2 | 3 | 2 | 3 => 0
+    case 4 | (_ @ 4) => 0
+    case _ => -1
+  }
+
+  a match {
+    case 1 => 1
+    case 0 | 0 => 0
+    case 2 | 2 | 2 | 3 | 2 | 3 => 0
+    case _ => -1
+  }
+}