[Deprecated] exhaustivity & redundancy check for pattern matching

src/dotty/tools/dotc/Compiler.scala

@@ -8,12 +8,8 @@ import Symbols._
 import Types._
 import Scopes._
 import typer.{FrontEnd, Typer, ImportInfo, RefChecks}
-import reporting.{Reporter, ConsoleReporter}
 import Phases.Phase
 import transform._
-import transform.TreeTransforms.{TreeTransform, TreeTransformer}
-import core.DenotTransformers.DenotTransformer
-import core.Denotations.SingleDenotation
 
 import dotty.tools.backend.jvm.{LabelDefs, GenBCode}
 import dotty.tools.backend.sjs.GenSJSIR

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/core/Phases.scala

@@ -1,17 +1,17 @@
 package dotty.tools.dotc
 package core
 
-import Periods._
 import Contexts._
-import dotty.tools.backend.jvm.{LabelDefs, GenBCode}
+import dotty.tools.backend.jvm.{GenBCode, LabelDefs}
 import dotty.tools.dotc.core.Symbols.ClassSymbol
 import util.DotClass
 import DenotTransformers._
 import Denotations._
 import Decorators._
 import config.Printers._
-import scala.collection.mutable.{ListBuffer, ArrayBuffer}
-import dotty.tools.dotc.transform.TreeTransforms.{TreeTransformer, MiniPhase, TreeTransform}
+
+import scala.collection.mutable.ListBuffer
+import dotty.tools.dotc.transform.TreeTransforms.{MiniPhase, TreeTransformer}
 import dotty.tools.dotc.transform._
 import Periods._
 import typer.{FrontEnd, RefChecks}

src/dotty/tools/dotc/core/Types.scala

@@ -810,6 +810,13 @@ object Types {
       case _ => this
     }
 
+    /** Eliminate anonymous classes */
+    final def deAnonymize(implicit ctx: Context): Type = this match {
+      case tp:TypeRef if tp.symbol.isAnonymousClass =>
+        tp.symbol.asClass.typeRef.asSeenFrom(tp.prefix, tp.symbol.owner)
+      case tp => tp
+    }
+
     /** Follow aliases and dereferences LazyRefs and instantiated TypeVars until type
      *  is no longer alias type, LazyRef, or instantiated type variable.
      */

src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -90,6 +90,7 @@ class ClassfileParser(
     val jflags       = in.nextChar
     val isAnnotation = hasAnnotation(jflags)
     val sflags       = classTranslation.flags(jflags)
+    val isEnum       = (jflags & JAVA_ACC_ENUM) != 0
     val nameIdx      = in.nextChar
     currentClassName = pool.getClassName(nameIdx)
 
@@ -145,6 +146,15 @@ class ClassfileParser(
       setClassInfo(classRoot, classInfo)
       setClassInfo(moduleRoot, staticInfo)
     }
+
+    // eager load java enum definitions for exhaustivity check of pattern match
+    if (isEnum) {
+      instanceScope.toList.map(_.ensureCompleted())
+      staticScope.toList.map(_.ensureCompleted())
+      classRoot.setFlag(Flags.Enum)
+      moduleRoot.setFlag(Flags.Enum)
+    }
+
     result
   }
 

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/PatternMatcher.scala

@@ -24,6 +24,7 @@ import Applications._
 import TypeApplications._
 import SymUtils._, core.NameOps._
 import core.Mode
+import patmat._
 
 import dotty.tools.dotc.util.Positions.Position
 import dotty.tools.dotc.core.Decorators._
@@ -52,6 +53,13 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
   override def transformMatch(tree: Match)(implicit ctx: Context, info: TransformerInfo): Tree = {
     val translated = new Translator()(ctx).translator.translateMatch(tree)
 
+    // check exhaustivity and unreachability
+    val engine = new SpaceEngine
+    if (engine.checkable(tree)) {
+      engine.checkExhaustivity(tree)
+      engine.checkRedundancy(tree)
+    }
+
     translated.ensureConforms(tree.tpe)
   }
 
@@ -1246,13 +1254,6 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
       case _                                                => false
     }
 
-    def elimAnonymousClass(t: Type) = t match {
-      case t:TypeRef if t.symbol.isAnonymousClass =>
-        t.symbol.asClass.typeRef.asSeenFrom(t.prefix, t.symbol.owner)
-      case _ =>
-        t
-    }
-
     /** Implement a pattern match by turning its cases (including the implicit failure case)
       * into the corresponding (monadic) extractors, and combining them with the `orElse` combinator.
       *
@@ -1266,7 +1267,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
     def translateMatch(match_ : Match): Tree = {
       val Match(sel, cases) = match_
 
-      val selectorTp = elimAnonymousClass(sel.tpe.widen/*withoutAnnotations*/)
+      val selectorTp = sel.tpe.widen.deAnonymize/*withoutAnnotations*/
 
       val selectorSym = freshSym(sel.pos, selectorTp, "selector")
 
@@ -1275,6 +1276,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
         case _                                                    => (cases, None)
       }
 
+
       // checkMatchVariablePatterns(nonSyntheticCases) // only used for warnings
 
       // we don't transform after uncurry

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

@@ -38,6 +38,8 @@ import Symbols._, TypeUtils._
  *
  *  (9) Adds SourceFile annotations to all top-level classes and objects
  *
+ *  (10) Adds Child annotations to all sealed classes
+ *
  *  The reason for making this a macro transform is that some functions (in particular
  *  super and protected accessors and instantiation checks) are naturally top-down and
  *  don't lend themselves to the bottom-up approach of a mini phase. The other two functions
@@ -231,6 +233,13 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer  { thisTran
                   ctx.compilationUnit.source.exists &&
                   sym != defn.SourceFileAnnot)
                 sym.addAnnotation(Annotation.makeSourceFile(ctx.compilationUnit.source.file.path))
+
+              if (!sym.isAnonymousClass) // ignore anonymous class
+                for (parent <- sym.asClass.classInfo.classParents) {
+                  val pclazz = parent.classSymbol
+                  if (pclazz.is(Sealed)) pclazz.addAnnotation(Annotation.makeChild(sym))
+                }
+
               tree
             }
             else {