Cover cases where other generics are erased

Author: felixmulder

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -1227,6 +1227,5 @@ object messages {
     val kind = "Erased Type"
     val msg =
       i"abstract type pattern is unchecked since it is eliminated by erasure"
-    val explanation = ""
   }
 }

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

@@ -5,7 +5,7 @@ import dotty.tools.dotc.util.Positions._
 import TreeTransforms.{MiniPhaseTransform, TransformerInfo}
 import core._
 import Contexts.Context, Types._, Constants._, Decorators._, Symbols._
-import TypeUtils._, TypeErasure._, Flags._
+import TypeUtils._, TypeErasure._, Flags._, TypeApplications._
 import reporting.diagnostic.messages._
 
 /** Implements partial evaluation of `sc.isInstanceOf[Sel]` according to:
@@ -128,6 +128,25 @@ 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(
+                ErasedType(hl"""|Since type parameters are erased, you should not match on them in
+                                |${"match"} expressions."""),
+                tree.pos
+              )
+              true
+            case x if tree.args.head.symbol is TypeParam =>
+              ctx.uncheckedWarning(
+                ErasedType(
+                  hl"""|`${tree.args.head.tpe}` will be erased to `${selector}`. Which means that the specified
+                       |behavior could be different during runtime."""
+                ),
+                tree.pos
+              )
+              true
+            case _ => false
+          }
 
           // Cases ---------------------------------
           val valueClassesOrAny =
@@ -149,11 +168,8 @@ class IsInstanceOfEvaluator extends MiniPhaseTransform { thisTransformer =>
 
           val inMatch = s.qualifier.symbol is Case
 
-          if (valueClassesOrAny) {
-            if ((selector eq defn.ObjectType))
-              ctx.uncheckedWarning(ErasedType(), tree.pos)
-            tree
-          } else if (knownStatically)
+          if (selTypeParam || valueClassesOrAny) tree
+          else if (knownStatically)
             handleStaticallyKnown(s, scrutinee, selector, inMatch, tree.pos)
           else if (falseIfUnrelated && scrutinee <:< selector)
             // scrutinee is a subtype of the selector, safe to rewrite

tests/repl/errmsgs.check

@@ -97,6 +97,8 @@ scala> def unsafeCast[S](a: Any) = a match { case s: S => s; case _ => ??? }
 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
@@ -107,4 +109,13 @@ java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.Stri
 	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 _ => ??? }
+-- [E034] 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> :quit