Revert Unsuppress unchecked warnings + restore warn/i21218

Author: WojciechMazur

compiler/src/dotty/tools/dotc/reporting/Message.scala

@@ -374,7 +374,7 @@ abstract class Message(val errorId: ErrorMessageID)(using Context) { self =>
     override def canExplain = true
 
   /** Override with `true` for messages that should always be shown even if their
-   *  position overlaps another message of a different class. On the other hand
+   *  position overlaps another messsage of a different class. On the other hand
    *  multiple messages of the same class with overlapping positions will lead
    *  to only a single message of that class to be issued.
    */

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

@@ -74,7 +74,7 @@ object TypeTestsCasts {
     }.apply(tp)
 
     /** Returns true if the type arguments of `P` can be determined from `X` */
-    def typeArgsDeterminable(X: Type, P: AppliedType)(using Context) = inContext(ctx.fresh.setExploreTyperState().setFreshGADTBounds) {
+    def typeArgsTrivial(X: Type, P: AppliedType)(using Context) = inContext(ctx.fresh.setExploreTyperState().setFreshGADTBounds) {
       val AppliedType(tycon, _) = P
 
       def underlyingLambda(tp: Type): TypeLambda = tp.ensureLambdaSub match {
@@ -155,7 +155,7 @@ object TypeTestsCasts {
           case x =>
             // always false test warnings are emitted elsewhere
             TypeComparer.provablyDisjoint(x, tpe.derivedAppliedType(tycon, targs.map(_ => WildcardType)))
-            || typeArgsDeterminable(X, tpe)
+            || typeArgsTrivial(X, tpe)
             ||| i"its type arguments can't be determined from $X"
         }
       case AndType(tp1, tp2)    => recur(X, tp1) && recur(X, tp2)

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

@@ -379,7 +379,7 @@ object SpaceEngine {
       project(pat)
 
     case Typed(_, tpt) =>
-      Typ(erase(tpt.tpe.stripAnnots, isValue = true, isTyped = true), decomposed = false)
+      Typ(erase(tpt.tpe.stripAnnots, isValue = true), decomposed = false)
 
     case This(_) =>
       Typ(pat.tpe.stripAnnots, decomposed = false)
@@ -464,13 +464,13 @@ object SpaceEngine {
         tp.derivedAppliedType(erase(tycon, inArray, isValue = false), args2)
 
       case tp @ OrType(tp1, tp2) =>
-        OrType(erase(tp1, inArray, isValue, isTyped), erase(tp2, inArray, isValue, isTyped), tp.isSoft)
+        OrType(erase(tp1, inArray, isValue), erase(tp2, inArray, isValue), tp.isSoft)
 
       case AndType(tp1, tp2) =>
-        AndType(erase(tp1, inArray, isValue, isTyped), erase(tp2, inArray, isValue, isTyped))
+        AndType(erase(tp1, inArray, isValue), erase(tp2, inArray, isValue))
 
       case tp @ RefinedType(parent, _, _) =>
-        erase(parent, inArray, isValue, isTyped)
+        erase(parent, inArray, isValue)
 
       case tref: TypeRef if tref.symbol.isPatternBound =>
         if inArray then erase(tref.underlying, inArray, isValue, isTyped)
@@ -905,7 +905,7 @@ object SpaceEngine {
   def checkMatch(m: Match)(using Context): Unit =
     checkMatchExhaustivityOnly(m)
     if reachabilityCheckable(m.selector) then checkReachability(m)
-  
+
   def checkMatchExhaustivityOnly(m: Match)(using Context): Unit =
     if exhaustivityCheckable(m.selector) then checkExhaustivity(m)
 }

tests/pending/neg/i16451.check

@@ -0,0 +1,24 @@
+-- Error: tests/neg/i16451.scala:13:9 ----------------------------------------------------------------------------------
+13 |    case x: Wrapper[Color.Red.type] => Some(x) // error
+   |         ^
+   |the type test for Wrapper[(Color.Red : Color)] cannot be checked at runtime because its type arguments can't be determined from Wrapper[Color]
+-- Error: tests/neg/i16451.scala:21:9 ----------------------------------------------------------------------------------
+21 |    case x: Wrapper[Color.Red.type] => Some(x) // error
+   |         ^
+   |the type test for Wrapper[(Color.Red : Color)] cannot be checked at runtime because its type arguments can't be determined from Any
+-- Error: tests/neg/i16451.scala:25:9 ----------------------------------------------------------------------------------
+25 |    case x: Wrapper[Color.Red.type] => Some(x) // error
+   |         ^
+   |the type test for Wrapper[(Color.Red : Color)] cannot be checked at runtime because its type arguments can't be determined from Wrapper[Color]
+-- Error: tests/neg/i16451.scala:29:9 ----------------------------------------------------------------------------------
+29 |    case x: Wrapper[Color.Red.type] => Some(x) // error
+   |         ^
+   |the type test for Wrapper[(Color.Red : Color)] cannot be checked at runtime because its type arguments can't be determined from A1
+-- Error: tests/neg/i16451.scala:34:11 ---------------------------------------------------------------------------------
+34 |      case x: Wrapper[Color.Red.type] => x // error
+   |           ^
+   |the type test for Wrapper[(Color.Red : Color)] cannot be checked at runtime because its type arguments can't be determined from Wrapper[Color]
+-- Error: tests/neg/i16451.scala:39:11 ---------------------------------------------------------------------------------
+39 |      case x: Wrapper[Color.Red.type] => x // error
+   |           ^
+   |the type test for Wrapper[(Color.Red : Color)] cannot be checked at runtime because its type arguments can't be determined from Wrapper[Color]

tests/warn/i16451.scala renamed to tests/pending/neg/i16451.scala

@@ -1,42 +1,38 @@
-//
+//> using options -Werror
 enum Color:
   case Red, Green
-//sealed trait Color
-//object Color:
-//  case object Red   extends Color
-//  case object Green extends Color
 
 case class Wrapper[A](value: A)
 
 object Test:
   def test_correct(x: Wrapper[Color]): Option[Wrapper[Color.Red.type]] = x match
-    case x: Wrapper[Color.Red.type]   => Some(x)                      // warn: unchecked
-    case x: Wrapper[Color.Green.type] => None    // warn: unreachable // also: unchecked (hidden)
+    case x: Wrapper[Color.Red.type] => Some(x) // error
+    case null                       => None
 
   def test_different(x: Wrapper[Color]): Option[Wrapper[Color]] = x match
     case x @ Wrapper(_: Color.Red.type)   => Some(x)
     case x @ Wrapper(_: Color.Green.type) => None
 
   def test_any(x: Any): Option[Wrapper[Color.Red.type]] = x match
-    case x: Wrapper[Color.Red.type]   => Some(x)                      // warn: unchecked
-    case x: Wrapper[Color.Green.type] => None    // warn: unreachable // also: unchecked (hidden)
+    case x: Wrapper[Color.Red.type] => Some(x) // error
+    case _                          => None
 
   def test_wrong(x: Wrapper[Color]): Option[Wrapper[Color.Red.type]] = x match
-    case x: Wrapper[Color.Red.type] => Some(x) // warn: unchecked
+    case x: Wrapper[Color.Red.type] => Some(x) // error
     case null                       => None
 
   def t2[A1 <: Wrapper[Color]](x: A1): Option[Wrapper[Color.Red.type]] = x match
-    case x: Wrapper[Color.Red.type] => Some(x) // warn: unchecked
+    case x: Wrapper[Color.Red.type] => Some(x) // error
     case null                       => None
 
   def test_wrong_seq(xs: Seq[Wrapper[Color]]): Seq[Wrapper[Color.Red.type]] =
     xs.collect {
-      case x: Wrapper[Color.Red.type] => x // warn: unchecked
+      case x: Wrapper[Color.Red.type] => x // error
     }
 
   def test_wrong_seq2(xs: Seq[Wrapper[Color]]): Seq[Wrapper[Color.Red.type]] =
     xs.collect { x => x match
-      case x: Wrapper[Color.Red.type] => x // warn: unchecked
+      case x: Wrapper[Color.Red.type] => x // error
     }
 
   def main(args: Array[String]): Unit =

tests/warn/enum-approx2.check

@@ -12,6 +12,7 @@ object Test1 {
   def test[A](bar: Bar[A]) =
     bar match {
       case _: Bar[Boolean] => ??? // warn
+      case _ => ???
     }
 }
 
@@ -22,6 +23,7 @@ object Test2 {
   def test[A](bar: Bar[A]) =
     bar match {
       case _: Bar[Boolean] => ??? // warn
+      case _ => ???
     }
 }
 
@@ -32,5 +34,6 @@ object Test3 {
   def test[A](bar: Bar[A]) =
     bar match {
       case _: Bar[Boolean] => ??? // warn
+      case _ => ???
     }
 }

tests/warn/enum-approx2.scala

@@ -10,20 +10,20 @@
   |the type test for List[Int] cannot be checked at runtime because its type arguments can't be determined from List[String]
   |
   | longer explanation available when compiling with `-explain`
--- [E092] Pattern Match Unchecked Warning: tests/warn/i5826.scala:16:9 -------------------------------------------------
-16 |    case ls: A[X] => 4                 // warn
+-- [E092] Pattern Match Unchecked Warning: tests/warn/i5826.scala:17:9 -------------------------------------------------
+17 |    case ls: A[X] => 4                 // warn
    |         ^
    |the type test for Foo.this.A[X] cannot be checked at runtime because its type arguments can't be determined from Foo.this.B[X]
    |
    | longer explanation available when compiling with `-explain`
--- [E092] Pattern Match Unchecked Warning: tests/warn/i5826.scala:21:9 -------------------------------------------------
-21 |    case ls: List[Int] => ls.head       // warn, List extends Int => T
+-- [E092] Pattern Match Unchecked Warning: tests/warn/i5826.scala:22:9 -------------------------------------------------
+22 |    case ls: List[Int] => ls.head       // warn, List extends Int => T
    |         ^
    |the type test for List[Int] cannot be checked at runtime because its type arguments can't be determined from A => Int
    |
    | longer explanation available when compiling with `-explain`
--- [E092] Pattern Match Unchecked Warning: tests/warn/i5826.scala:27:54 ------------------------------------------------
-27 |  def test5[T](x: A[T] | B[T] | Option[T]): Boolean = x.isInstanceOf[C[String]] // warn
+-- [E092] Pattern Match Unchecked Warning: tests/warn/i5826.scala:28:54 ------------------------------------------------
+28 |  def test5[T](x: A[T] | B[T] | Option[T]): Boolean = x.isInstanceOf[C[String]] // warn
    |                                                      ^
    |the type test for Foo.this.C[String] cannot be checked at runtime because its type arguments can't be determined from Foo.this.A[T]
    |

tests/warn/i11178.scala

@@ -6,6 +6,7 @@ class Foo {
 
   def test2: List[Int] | List[String] => Int = {
     case ls: List[Int] => ls.head       // warn: unchecked
+    case _ => 0
   }
 
   trait A[T]

tests/warn/i16451.check

@@ -6,7 +6,7 @@ class Dummy extends Bar[Nothing] with Foo[String]
 def bugReport[A](foo: Foo[A]): Foo[A] =
   foo match {
     case bar: Bar[A] => bar    // warn: unchecked
-    case dummy: Dummy => ???   // warn: unreachable
+    case dummy: Dummy => ???
   }
 
 def test = bugReport(new Dummy: Foo[String])

tests/warn/i5826.check

@@ -1,11 +1,9 @@
 object Test {
   sealed trait Foo[A, B]
   final case class Bar[X](x: X) extends Foo[X, X]
-
   def foo[A, B](value: Foo[A, B], a: A => Int): B = value match {
     case Bar(x) => a(x); x
   }
-
   def bar[A, B](value: Foo[A, B], a: A => Int): B = value match {
     case b: Bar[a] => b.x
   }
@@ -18,10 +16,12 @@ object Test {
   def err2[A, B](value: Foo[A, B], a: A => Int): B = value match {
     case b: Bar[B] => // spurious // warn
       b.x
+    case _ => ??? // avoid fatal inexhaustivity warnings suppressing the uncheckable warning
   }
 
   def fail[A, B](value: Foo[A, B], a: A => Int): B = value match {
     case b: Bar[Int] => // warn
       b.x
+    case _ => ??? // avoid fatal inexhaustivity warnings suppressing the uncheckable warning
   }
-}
+}