Don't warn for erasure on arrays with value types

Author: felixmulder

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

@@ -129,8 +129,14 @@ class IsInstanceOfEvaluator extends MiniPhaseTransform { thisTransformer =>
           val selClassNonFinal = selClass && !(selector.typeSymbol is Final)
           val selFinalClass    = selClass && (selector.typeSymbol is Final)
           val selTypeParam     = tree.args.head.tpe.widen match {
-            case AppliedType(tycon, args) =>
-              ctx.uncheckedWarning(
+            case tp @ AppliedType(tycon, args) =>
+              // If the type is Array[X] where x extends AnyVal, this shouldn't yield a warning:
+              val illegalComparison = !(tp.isRef(defn.ArrayClass) && {
+                args.head.derivesFrom(defn.AnyValClass) ||
+                args.head.isRef(defn.AnyClass)
+              })
+
+              if (illegalComparison) ctx.uncheckedWarning(
                 ErasedType(hl"""|Since type parameters are erased, you should not match on them in
                                 |${"match"} expressions."""),
                 tree.pos

tests/repl/erasure.check

@@ -0,0 +1,53 @@
+scala> def unsafeCast[S](a: Any) = a match { case s: S => s; case _ => ??? }
+-- [E035] Erased Type Unchecked Warning: <console> -----------------------------
+4 |def unsafeCast[S](a: Any) = a match { case s: S => s; case _ => ??? }
+  |                                                ^
+  |      abstract type pattern is unchecked since it is eliminated by erasure
+
+longer explanation available when compiling with `-explain`
+def unsafeCast[S](a: Any): [S] => (a: Any)S
+scala> unsafeCast[String](1)
+java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
+	at .<init>(<console>:6)
+	at .<clinit>(<console>)
+	at RequestResult$.<init>(<console>:3)
+	at RequestResult$.<clinit>(<console>)
+	at RequestResult$result(<console>)
+	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
+	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.jav...
+scala> class A; def unsafeCast2[S <: A](a: Any) = a match { case s: S => s; case _ => ??? }
+-- [E035] Erased Type Unchecked Warning: <console> -----------------------------
+4 |class A; def unsafeCast2[S <: A](a: Any) = a match { case s: S => s; case _ => ??? }
+  |                                                               ^
+  |      abstract type pattern is unchecked since it is eliminated by erasure
+
+longer explanation available when compiling with `-explain`
+defined class A
+def unsafeCast2[S <: A](a: Any): [S <: A] => (a: Any)S
+scala> def matchArray1[A](xs: Array[A]) = xs match { case xs: Array[Int] => xs; case xs: Array[A] => ??? }
+def matchArray1[A](xs: Array[A]): [A] => (xs: Array[A])Array[Int]
+scala> def matchArray2[A](xs: Array[Any]) = xs match { case xs: Array[Int] => xs; case xs: Array[A] => ??? }
+-- [E035] Erased Type Unchecked Warning: <console> -----------------------------
+5 |def matchArray2[A](xs: Array[Any]) = xs match { case xs: Array[Int] => xs; case xs: Array[A] => ??? }
+  |                                                                                             ^
+  |      abstract type pattern is unchecked since it is eliminated by erasure
+
+longer explanation available when compiling with `-explain`
+def matchArray2[A](xs: Array[Any]): [A] => (xs: Array[Any])Array[Int]
+scala> def matchArray3[A](xs: Array[A]) = xs match { case xs: Array[Int] => xs; case xs: Array[AnyRef] => ???; case xs: Array[Any] => ??? }
+-- [E035] Erased Type Unchecked Warning: <console> -----------------------------
+5 |def matchArray3[A](xs: Array[A]) = xs match { case xs: Array[Int] => xs; case xs: Array[AnyRef] => ???; case xs: Array[Any] => ??? }
+  |                                                                                                ^
+  |      abstract type pattern is unchecked since it is eliminated by erasure
+
+longer explanation available when compiling with `-explain`
+def matchArray3[A](xs: Array[A]): [A] => (xs: Array[A])Array[Int]
+scala> def matchArray4(xs: Array[Any]) = xs match { case xs: Array[Int] => xs; case xs: Array[A] => ???; case xs: Array[Any] => ??? }
+-- [E035] Erased Type Unchecked Warning: <console> -----------------------------
+5 |def matchArray4(xs: Array[Any]) = xs match { case xs: Array[Int] => xs; case xs: Array[A] => ???; case xs: Array[Any] => ??? }
+  |                                                                                          ^
+  |      abstract type pattern is unchecked since it is eliminated by erasure
+
+longer explanation available when compiling with `-explain`
+def matchArray4(xs: Array[Any]): Array[Int]
+scala> :quit