Check invariant of function encoding

Check that function literals are always encoded as follows before LambdaLift:

```
{
    def anon(...) = ...
    closure(anon)
}
```

Author: liufengyun

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

@@ -353,6 +353,7 @@ object Phases {
     private[this] var myErasedTypes = false
     private[this] var myFlatClasses = false
     private[this] var myRefChecked = false
+    private[this] var myLambdaLifted = false
 
     private[this] var mySameMembersStartId = NoPhaseId
     private[this] var mySameParentsStartId = NoPhaseId
@@ -371,6 +372,7 @@ 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 sameMembersStartId: Int = mySameMembersStartId
       // id of first phase where all symbols are guaranteed to have the same members as in this phase
@@ -388,6 +390,7 @@ object Phases {
       myErasedTypes  = prev.getClass == classOf[Erasure]   || prev.erasedTypes
       myFlatClasses  = prev.getClass == classOf[Flatten]   || prev.flatClasses
       myRefChecked   = prev.getClass == classOf[RefChecks] || prev.refChecked
+      myLambdaLifted   = prev.getClass == classOf[LambdaLift] || prev.lambdaLifted
       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

@@ -178,6 +178,16 @@ class TreeChecker extends Phase with SymTransformer {
       res
     }
 
+    // used to check invariant of lambda encoding
+    var nestingBlock: untpd.Block | Null = null
+    private def withBlock[T](block: untpd.Block)(op: => T): T = {
+      val outerBlock = nestingBlock
+      nestingBlock = block
+      val res = op
+      nestingBlock = outerBlock
+      res
+    }
+
     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)
@@ -407,8 +417,22 @@ class TreeChecker extends Phase with SymTransformer {
       }
     }
 
+    override def typedClosure(tree: untpd.Closure, pt: Type)(implicit ctx: Context): Tree = {
+      if (!ctx.phase.lambdaLifted) nestingBlock match {
+        case Block((meth : DefDef) :: Nil, closure: Closure) =>
+          assert(meth.symbol == closure.meth.symbol, "closure.meth symbol not equal to method symbol. Block: " + nestingBlock.show)
+
+        case block: untpd.Block =>
+          assert(false, "function literal are not properly formed as a block of DefDef and Closure. Found: " + tree.show + " Nesting block: " + block.show)
+
+        case null =>
+          assert(false, "function literal are not properly formed as a block of DefDef and Closure. Found: " + tree.show + " Nesting block: null")
+      }
+      super.typedClosure(tree, pt)
+    }
+
     override def typedBlock(tree: untpd.Block, pt: Type)(implicit ctx: Context): Tree =
-      withDefinedSyms(tree.stats) { super.typedBlock(tree, pt) }
+      withBlock(tree) { withDefinedSyms(tree.stats) { super.typedBlock(tree, pt) } }
 
     override def typedInlined(tree: untpd.Inlined, pt: Type)(implicit ctx: Context): Tree =
       withDefinedSyms(tree.bindings) { super.typedInlined(tree, pt) }

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

@@ -730,7 +730,7 @@ class Typer extends Namer
    */
   protected def ensureNoLocalRefs(tree: Tree, pt: Type, localSyms: => List[Symbol])(implicit ctx: Context): Tree = {
     def ascribeType(tree: Tree, pt: Type): Tree = tree match {
-      case block @ Block(stats, expr) =>
+      case block @ Block(stats, expr) if !expr.isInstanceOf[Closure] =>
         val expr1 = ascribeType(expr, pt)
         cpy.Block(block)(stats, expr1) withType expr1.tpe // no assignType here because avoid is redundant
       case _ =>
@@ -3081,7 +3081,7 @@ class Typer extends Namer
     }
 
     tree match {
-      case _: MemberDef | _: PackageDef | _: Import | _: WithoutTypeOrPos[_] => tree
+      case _: MemberDef | _: PackageDef | _: Import | _: WithoutTypeOrPos[_] | _: Closure => tree
       case _ => tree.tpe.widen match {
         case tp: FlexType =>
           ensureReported(tp)