suppress checking of for, try and partial functions

src/dotty/tools/dotc/ast/Desugar.scala

@@ -616,16 +616,20 @@ object desugar {
    *
    *       { cases }
    *  ==>
-   *       x$1 => x$1 match { cases }
+   *       x$1 => (x$1 @unchecked) match { cases }
    *
    *  If `nparams` != 1, expand instead to
    *
-   *       (x$1, ..., x$n) => (x$0, ..., x${n-1}) match { cases }
+   *       (x$1, ..., x$n) => (x$0, ..., x${n-1} @unchecked) match { cases }
    */
-  def makeCaseLambda(cases: List[CaseDef], nparams: Int = 1)(implicit ctx: Context) = {
+  def makeCaseLambda(cases: List[CaseDef], nparams: Int = 1, unchecked: Boolean = true)(implicit ctx: Context) = {
     val params = (1 to nparams).toList.map(makeSyntheticParameter(_))
     val selector = makeTuple(params.map(p => Ident(p.name)))
-    Function(params, Match(selector, cases))
+
+    if (unchecked)
+      Function(params, Match(Annotated(New(ref(defn.UncheckedAnnotType)), selector), cases))
+    else
+      Function(params, Match(selector, cases))
   }
 
   /** Map n-ary function `(p1, ..., pn) => body` where n != 1 to unary function as follows:
@@ -753,7 +757,7 @@ object desugar {
         case VarPattern(named, tpt) =>
           Function(derivedValDef(named, tpt, EmptyTree, Modifiers(Param)) :: Nil, body)
         case _ =>
-          makeCaseLambda(CaseDef(pat, EmptyTree, body) :: Nil)
+          makeCaseLambda(CaseDef(pat, EmptyTree, body) :: Nil, unchecked = false)
       }
 
       /** If `pat` is not an Identifier, a Typed(Ident, _), or a Bind, wrap
@@ -799,7 +803,7 @@ object desugar {
         val cases = List(
           CaseDef(pat, EmptyTree, Literal(Constant(true))),
           CaseDef(Ident(nme.WILDCARD), EmptyTree, Literal(Constant(false))))
-        Apply(Select(rhs, nme.withFilter), Match(EmptyTree, cases))
+        Apply(Select(rhs, nme.withFilter), makeCaseLambda(cases))
       }
 
       /** Is pattern `pat` irrefutable when matched against `rhs`?

src/dotty/tools/dotc/transform/ExpandSAMs.scala

@@ -74,7 +74,8 @@ class ExpandSAMs extends MiniPhaseTransform { thisTransformer =>
             Bind(defaultSym, Underscore(selector.tpe.widen)),
             EmptyTree,
             Literal(Constant(false)))
-        cpy.Match(applyRhs)(paramRef, cases.map(translateCase) :+ defaultCase)
+        val annotated = Annotated(New(ref(defn.UncheckedAnnotType)), paramRef)
+        cpy.Match(applyRhs)(annotated, cases.map(translateCase) :+ defaultCase)
       case _ =>
         tru
     }

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

@@ -258,7 +258,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
     case UnApply(_, _, pats) =>
       if (pat.tpe.classSymbol.is(CaseClass))
         Kon(pat.tpe.stripAnnots, pats.map(pat => project(pat, roundUp)))
-      else if (roundUp) Typ(pat.tpe, false)
+      else if (roundUp) Typ(pat.tpe.stripAnnots, false)
       else Empty
     case Typed(pat @ UnApply(_, _, _), _) => project(pat)
     case Typed(expr, _) => Typ(expr.tpe.stripAnnots, true)
@@ -392,9 +392,9 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
       case _ => tp.show.stripSuffix("$")
     }
 
-    val text = tp match {
+    val text = tp.stripAnnots match {
       case tp: OrType => showType(tp.tp1) + " | " + showType(tp.tp2)
-      case _ => refine(tp)
+      case tp => refine(tp)
     }
 
     if (text.isEmpty) enclosingCls.show.stripSuffix("$")

src/dotty/tools/dotc/typer/TypeAssigner.scala

@@ -470,7 +470,7 @@ trait TypeAssigner {
     tree.withType(sym.nonMemberTermRef)
 
   def assignType(tree: untpd.Annotated, annot: Tree, arg: Tree)(implicit ctx: Context) =
-    tree.withType(AnnotatedType(arg.tpe, Annotation(annot)))
+    tree.withType(AnnotatedType(arg.tpe.widen, Annotation(annot)))
 
   def assignType(tree: untpd.PackageDef, pid: Tree)(implicit ctx: Context) =
     tree.withType(pid.symbol.valRef)

src/dotty/tools/dotc/typer/Typer.scala

@@ -719,7 +719,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     tree.selector match {
       case EmptyTree =>
         val (protoFormals, _) = decomposeProtoFunction(pt, 1)
-        typed(desugar.makeCaseLambda(tree.cases, protoFormals.length) withPos tree.pos, pt)
+        val unchecked = pt <:< defn.PartialFunctionType
+        typed(desugar.makeCaseLambda(tree.cases, protoFormals.length, unchecked) withPos tree.pos, pt)
       case _ =>
         val sel1 = typedExpr(tree.selector)
         val selType = widenForMatchSelector(

test/test/transform/PatmatExhaustivityTest.scala

@@ -10,15 +10,15 @@ import dotty.tools.dotc.reporting.ConsoleReporter
 
 class PatmatExhaustivityTest {
   val testsDir = "./tests/patmat"
-  val options = "-Ystop-after:splitter"  // no need for code generation
-                                         // patmatexhaust-huge.scala crash compiler
+  // stop-after: patmatexhaust-huge.scala crash compiler
+  val options = List("-Ystop-after:splitter")
 
   private def compileFile(file: File) = {
     val stringBuffer = new StringWriter()
     val reporter = new ConsoleReporter(writer = new PrintWriter(stringBuffer))
 
     try {
-      Main.process(Array(file.getPath, options), reporter, null)
+      Main.process((file.getPath::options).toArray, reporter, null)
     } catch {
       case e: Throwable =>
         println(s"Compile $file exception:")
@@ -45,7 +45,7 @@ class PatmatExhaustivityTest {
       .map(_.jfile.getPath)
 
     try {
-      Main.process((options::files).toArray, reporter, null)
+      Main.process((options ++ files).toArray, reporter, null)
     } catch {
       case e: Throwable =>
         println(s"Compile $file exception:")

tests/patmat/for.scala

@@ -0,0 +1,5 @@
+object Test {
+  def foo[A, B](l: List[(A, B)]): List[A] = {
+    for ((a, b) <- l) yield a
+  }
+}

tests/patmat/i947.check

@@ -0,0 +1,4 @@
+./tests/patmat/i947.scala:10: warning: unreachable code
+      case ys: List[d18383] => false
+                           ^
+one warning found

tests/patmat/i947.scala

@@ -0,0 +1,16 @@
+object Test {
+
+  class c {
+
+    private var x: Int = 0
+
+    override def equals(other: Any) = other match {
+      case o: c => x == o.x
+      case xs: List[c] => false
+      case ys: List[d18383] => false
+      case _ => false
+    }
+
+
+  }
+}

tests/patmat/partial-function.scala

@@ -0,0 +1,12 @@
+sealed abstract class TA
+sealed abstract class TB extends TA
+case object B extends TB
+case object B2 extends TB
+
+case class CC(i: Int, tb: TB)
+
+object Test {
+  def foo: PartialFunction[CC, Unit] = {
+    case CC(_, B) => ()
+  }
+}

tests/patmat/t1056.scala

@@ -0,0 +1,5 @@
+object Test {
+  type T = PartialFunction[String,String]
+  def g(h: T) = ()
+  g({case s: String => s})
+}

tests/patmat/try.scala

@@ -0,0 +1,5 @@
+object Test {
+  try 2/0 catch {
+    case e: Exception =>
+  }
+}