refine patmat check for type erasure

src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -251,7 +251,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
             Typ(tp.widenTermRefExpr.stripAnnots, false)
           else
             Var(pat.symbol, tp)
-        case tp => Typ(tp, false)
+        case tp => Typ(erase(tp), false)
       }
     case Alternative(trees) => Or(trees.map(project(_, roundUp)))
     case Bind(_, pat) => project(pat)
@@ -261,11 +261,22 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
       else if (roundUp) Typ(pat.tpe.stripAnnots, false)
       else Empty
     case Typed(pat @ UnApply(_, _, _), _) => project(pat)
-    case Typed(expr, _) => Typ(expr.tpe.stripAnnots, true)
+    case Typed(expr, _) => Typ(erase(expr.tpe.stripAnnots), true)
     case _ =>
       Empty
   }
 
+  /* Erase a type binding according to erasure rule */
+  def erase(tp: Type): Type = {
+    def doErase(tp: Type): Type = tp match {
+      case tp: RefinedType => erase(tp.parent)
+      case _ => tp
+    }
+
+    val origin = doErase(tp)
+    if (origin =:= defn.ArrayType) tp else origin
+  }
+
   /** Is `tp1` a subtype of `tp2`?  */
   def isSubType(tp1: Type, tp2: Type): Boolean = tp1 <:< tp2
 

tests/patmat/t2425.scala

@@ -0,0 +1,15 @@
+trait B
+class D extends B
+object Test extends App {
+  def foo[T](bar: T) = {
+    bar match {
+      case _: Array[Array[_]] => println("array 2d")
+      case _: Array[_] => println("array 1d")
+      case _ => println("something else")
+    }
+  }
+  foo(Array.fill(10)(2))
+  foo(Array.fill(10, 10)(2))
+  foo(Array.fill(10, 10, 10)(2))
+  foo(List(1, 2, 3))
+}