fix #3144: emit warnings for unchecked type patterns

Author: liufengyun

compiler/src/dotty/tools/dotc/reporting/diagnostic/ErrorMessageID.java

@@ -97,6 +97,7 @@ public enum ErrorMessageID {
     DuplicatePrivateProtectedQualifierID,
     ExpectedStartOfTopLevelDefinitionID,
     MissingReturnTypeWithReturnStatementID,
+    UncheckedTypePatternID,
     ;
 
     public int errorNumber() {

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

@@ -880,6 +880,16 @@ object messages {
            |"""
   }
 
+  case class UncheckedTypePattern(msg: String)(implicit ctx: Context)
+    extends Message(UncheckedTypePatternID) {
+    val kind = "Unchecked Type Pattern"
+
+    val explanation =
+      hl"""|Type arguments and type refinements are erased during compile time, thus it's
+           |impossible to check them at run-time.
+           |"""
+  }
+
   case class MatchCaseUnreachable()(implicit ctx: Context)
   extends Message(MatchCaseUnreachableID) {
     val kind = s"""Match ${hl"case"} Unreachable"""

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

@@ -7,7 +7,7 @@ import Types._
 import Contexts._
 import Flags._
 import ast.Trees._
-import ast.{tpd, untpd}
+import ast.tpd
 import Decorators._
 import Symbols._
 import StdNames._
@@ -20,6 +20,7 @@ import ProtoTypes._
 import transform.SymUtils._
 import reporting.diagnostic.messages._
 import config.Printers.{exhaustivity => debug}
+import util.Positions.Position
 
 /** Space logic for checking exhaustivity and unreachability of pattern matching
  *
@@ -403,21 +404,30 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
       else
         Prod(pat.tpe.stripAnnots, fun.tpe.widen, fun.symbol, pats.map(project), irrefutable(fun))
     case Typed(pat @ UnApply(_, _, _), _) => project(pat)
-    case Typed(expr, _) => Typ(erase(expr.tpe.stripAnnots), true)
+    case Typed(expr, tp) => Typ(erase(expr.tpe.stripAnnots)(tp.pos), true)
     case _ =>
       debug.println(s"unknown pattern: $pat")
       Empty
   }
 
   /* Erase a type binding according to erasure semantics in pattern matching */
-  def erase(tp: Type): Type = tp match {
+  def erase(tp: Type)(implicit pos: Position): Type = tp match {
     case tp @ AppliedType(tycon, args) =>
       if (tycon.isRef(defn.ArrayClass)) tp.derivedAppliedType(tycon, args.map(erase))
-      else tp.derivedAppliedType(tycon, args.map(t => WildcardType))
+      else {
+        val ignoreWarning = args.forall(p => p.typeSymbol.is(BindDefinedType) || p.isInstanceOf[TypeBounds])
+        if (!ignoreWarning)
+          ctx.warning(UncheckedTypePattern("type arguments are not unchecked since they are eliminated by erasure"), pos)
+
+        tp.derivedAppliedType(tycon, args.map(t => WildcardType))
+      }
     case OrType(tp1, tp2) =>
       OrType(erase(tp1), erase(tp2))
     case AndType(tp1, tp2) =>
       AndType(erase(tp1), erase(tp2))
+    case tp: RefinedType =>
+      ctx.warning(UncheckedTypePattern("type refinement is not unchecked since it is eliminated by erasure"), pos)
+      tp.derivedRefinedType(erase(tp.parent), tp.refinedName, WildcardType)
     case _ => tp
   }
 

tests/patmat/3144.check

@@ -0,0 +1,2 @@
+2: Unchecked Type Pattern
+7: Unchecked Type Pattern

tests/patmat/3144.scala

@@ -0,0 +1,9 @@
+sealed trait Foo[T]
+case class Bar[T](s: String)
+
+object Test {
+  def shouldError[T](foo: Foo[T]): String =
+    foo match {
+      case bar: Bar[T] => bar.s
+    }
+}

tests/patmat/enum-HList.check

@@ -0,0 +1 @@
+2: Unchecked Type Pattern

tests/patmat/enum-Tree.check

@@ -0,0 +1 @@
+8: Unchecked Type Pattern

tests/patmat/t10019.check

@@ -0,0 +1,2 @@
+2: Pattern Match Exhaustivity: (List(_, _: _*), Nil), (List(_, _: _*), List(_, _, _: _*)), (Nil, List(_, _: _*)), (List(_, _, _: _*), List(_, _: _*))
+11: Pattern Match Exhaustivity: (Foo(None), Foo(_))

tests/patmat/t10019.scala

@@ -0,0 +1,14 @@
+object Bug {
+  def foo[T](t1: List[T], t2: List[T]) = (t1, t2) match {
+    case (Nil, Nil) => ()
+    case (List(_), List(_)) => ()
+  }
+}
+
+object Bug2 {
+  sealed case class Foo(e: Option[Int])
+
+  def loop(s: Foo, t: Foo): Nothing = (s,t) match {
+    case (Foo(Some(_)), _) => ???
+  }
+}

tests/patmat/t3683.check

@@ -0,0 +1 @@
+7: Unchecked Type Pattern

tests/patmat/t3683a.check

@@ -1 +1,2 @@
+8: Unchecked Type Pattern
 14: Pattern Match Exhaustivity: XX()