Check invariant about the flags of pattern-bound symbols

The following invariant should be true for pattern-bound symbols,
and *only* for pattern-bound symbols:

    (sym.isType && !sym.isClass && sym.isOneOf(Case)) ||
      (sym.isTerm && sym.isOneOf(Case, butNot = Enum | Module))

The invariant only holds before patternMatcher.
After patternMatcher, there are no more pattern trees,
thus the invariant does not hold any more.

Author: liufengyun

compiler/src/dotty/tools/dotc/core/Phases.scala

@@ -354,6 +354,7 @@ object Phases {
     private[this] var myFlatClasses = false
     private[this] var myRefChecked = false
     private[this] var myLambdaLifted = false
+    private[this] var myPatternTranslated = false
 
     private[this] var mySameMembersStartId = NoPhaseId
     private[this] var mySameParentsStartId = NoPhaseId
@@ -372,7 +373,8 @@ object Phases {
     final def erasedTypes: Boolean = myErasedTypes   // Phase is after erasure
     final def flatClasses: Boolean = myFlatClasses   // Phase is after flatten
     final def refChecked: Boolean = myRefChecked     // Phase is after RefChecks
-    final def lambdaLifted: Boolean = myLambdaLifted     // Phase is after LambdaLift
+    final def lambdaLifted: Boolean = myLambdaLifted // Phase is after LambdaLift
+    final def patternTranslated: Boolean = myPatternTranslated // Phase is after PatternMatcher
 
     final def sameMembersStartId: Int = mySameMembersStartId
       // id of first phase where all symbols are guaranteed to have the same members as in this phase
@@ -391,6 +393,7 @@ object Phases {
       myFlatClasses  = prev.getClass == classOf[Flatten]    || prev.flatClasses
       myRefChecked   = prev.getClass == classOf[RefChecks]  || prev.refChecked
       myLambdaLifted = prev.getClass == classOf[LambdaLift] || prev.lambdaLifted
+      myPatternTranslated = prev.getClass == classOf[PatternMatcher] || prev.patternTranslated
       mySameMembersStartId = if (changesMembers) id else prev.sameMembersStartId
       mySameParentsStartId = if (changesParents) id else prev.sameParentsStartId
       mySameBaseTypesStartId = if (changesBaseTypes) id else prev.sameBaseTypesStartId

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

@@ -131,6 +131,7 @@ class TreeChecker extends Phase with SymTransformer {
   class Checker(phasesToCheck: Seq[Phase]) extends ReTyper with Checking {
 
     private[this] val nowDefinedSyms = new mutable.HashSet[Symbol]
+    private[this] val patBoundSyms = new mutable.HashSet[Symbol]
     private[this] val everDefinedSyms = newMutableSymbolMap[untpd.Tree]
 
     // don't check value classes after typer, as the constraint about constructors doesn't hold after transform
@@ -171,10 +172,25 @@ class TreeChecker extends Phase with SymTransformer {
       res
     }
 
+    /** The following invariant holds:
+     *
+     *  patBoundSyms.contains(sym) <=> patternBound(sym)
+     */
+    def patternBound(sym: Symbol)(implicit ctx: Context): Boolean =
+      (sym.isType && !sym.isClass && sym.isOneOf(Case)) ||
+        (sym.isTerm && sym.isOneOf(Case, butNot = Enum | Module))
+
     def withPatSyms[T](syms: List[Symbol])(op: => T)(implicit ctx: Context): T = {
-      nowDefinedSyms ++= syms
+      syms.foreach { sym =>
+        assert(
+          patternBound(sym),
+          "patBoundSyms.contains(sym) => patternBound(sym) is broken." +
+          " Pattern bound symbol has incorrect flags: " + sym.flags + ", line " + sym.sourcePos.line
+        )
+      }
+      patBoundSyms ++= syms
       val res = op
-      nowDefinedSyms --= syms
+      patBoundSyms --= syms
       res
     }
 
@@ -189,8 +205,19 @@ class TreeChecker extends Phase with SymTransformer {
     }
 
     def assertDefined(tree: untpd.Tree)(implicit ctx: Context): Unit =
-      if (tree.symbol.maybeOwner.isTerm)
-        assert(nowDefinedSyms contains tree.symbol, i"undefined symbol ${tree.symbol} at line " + tree.sourcePos.line)
+      if (tree.symbol.maybeOwner.isTerm) {
+        val sym = tree.symbol
+        assert(
+          nowDefinedSyms.contains(sym) || patBoundSyms.contains(sym),
+          i"undefined symbol ${sym} at line " + tree.sourcePos.line
+        )
+
+        if (!ctx.phase.patternTranslated)
+          assert(
+            !patternBound(sym) || patBoundSyms.contains(sym),
+            "patternBound(sym) => patBoundSyms.contains(sym) is broken, line " + tree.sourcePos.line
+          )
+      }
 
     /** assert Java classes are not used as objects */
     def assertIdentNotJavaClass(tree: Tree)(implicit ctx: Context): Unit = tree match {