Relax warnings when matching from Seq to List

Author: felixmulder

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -357,6 +357,9 @@ class Definitions {
       List(AnyClass.typeRef), EmptyScope)
   def SingletonType = SingletonClass.typeRef
 
+  lazy val ListType: TypeRef = ctx.requiredClassRef("scala.collection.immutable.List")
+  def ListClass(implicit ctx: Context) = ListType.symbol.asClass
+
   lazy val SeqType: TypeRef = ctx.requiredClassRef("scala.collection.Seq")
   def SeqClass(implicit ctx: Context) = SeqType.symbol.asClass
 

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

@@ -146,11 +146,27 @@ class IsInstanceOfEvaluator extends MiniPhaseTransform { thisTransformer =>
               // has @unchecked annotation to suppress warnings
               val hasUncheckedAnnot = arg.hasAnnotation(defn.UncheckedAnnot)
 
-              if (!topType && !hasUncheckedAnnot && !anyValArray) ctx.uncheckedWarning(
-                ErasedType(hl"""|Since type parameters are erased, you should not match on them in
-                                |${"match"} expressions."""),
-                tree.pos
-              )
+              // we don't want to warn when matching on `List` from `Seq` e.g:
+              // (xs: Seq[Int]) match { case xs: List[Int] => ??? }
+              val matchingSeqToList = {
+                val hasSameTypeArgs = s.qualifier.tpe.widen match {
+                  case AppliedType(_, scrutArg :: Nil) =>
+                    (scrutArg eq arg) || arg <:< scrutArg
+                  case _ => false
+                }
+
+                scrutinee.isRef(defn.SeqClass) &&
+                tp.isRef(defn.ListClass) &&
+                hasSameTypeArgs
+              }
+
+              if (!topType && !hasUncheckedAnnot && !matchingSeqToList && !anyValArray) {
+                ctx.uncheckedWarning(
+                  ErasedType(hl"""|Since type parameters are erased, you should not match on them in
+                                  |${"match"} expressions."""),
+                  tree.pos
+                )
+              }
               true
             case _ =>
               if (tree.args.head.symbol.is(TypeParam)) {

tests/repl/erasure.check

@@ -52,4 +52,8 @@ scala> def matchList2(xs: List[Any]) = xs match { case List() => ???; case _ =>
 def matchList2(xs: List[Any]): Nothing
 scala> def matchList3(xs: Seq[_]) = xs match { case List() => ???; case _ => ??? }
 def matchList3(xs: Seq[_]): Nothing
+scala> val xs: Seq[Int] = Seq(1,2,3)
+val xs: scala.collection.Seq[Int] = List(1, 2, 3)
+scala> val xsMatch = xs match { case ss: List[Int] => 1 }
+val xsMatch: Int = 1
 scala> :quit