Removed CheckTrees

It was unmaintained and superseded by TreeChecker. The only needed bit,
escapingRefs, got moved to Typer.

Author: odersky

src/dotty/tools/dotc/ast/CheckTrees.scala renamed to src/dotty/tools/dotc/ast/CheckTrees.scala.disabled

@@ -6,7 +6,7 @@ import core._
 import dotty.tools.dotc.transform.TypeUtils
 import util.Positions._, Types._, Contexts._, Constants._, Names._, Flags._
 import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._, Symbols._
-import CheckTrees._, Denotations._, Decorators._
+import Denotations._, Decorators._
 import config.Printers._
 import typer.ErrorReporting._
 
@@ -134,7 +134,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     TypeTree(original.tpe, original)
 
   def TypeTree(tp: Type, original: Tree = EmptyTree)(implicit ctx: Context): TypeTree =
-    untpd.TypeTree(original).withType(tp).checked
+    untpd.TypeTree(original).withType(tp)
 
   def SingletonTypeTree(ref: Tree)(implicit ctx: Context): SingletonTypeTree =
     ta.assignType(untpd.SingletonTypeTree(ref), ref)
@@ -237,7 +237,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     val localDummy = ((NoSymbol: Symbol) /: body)(findLocalDummy)
       .orElse(ctx.newLocalDummy(cls))
     val impl = untpd.Template(constr, parents, selfType, newTypeParams ++ body)
-      .withType(localDummy.termRef).checked
+      .withType(localDummy.termRef)
     ta.assignType(untpd.TypeDef(Modifiers(cls), cls.name, impl), cls)
   }
 
@@ -354,11 +354,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       case _ => false
     }
 
-    def checked(implicit ctx: Context): ThisTree = {
-      if (ctx.settings.YcheckTypedTrees.value) checkType(tree)
-      tree
-    }
-
     def shallowFold[T](z: T)(op: (T, tpd.Tree) => T) =
       new ShallowFolder(op).apply(z, tree)
 

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

@@ -114,15 +114,15 @@ class VarianceChecker(implicit ctx: Context) {
           ctx.debuglog(s"Skipping variance check of ${sym.showDcl}")
         case tree: TypeDef =>
           checkVariance(sym)
-          super.traverse(tree)
+          foldOver((), tree)
         case tree: ValDef =>
           checkVariance(sym)
         case DefDef(_, _, tparams, vparamss, _, _) =>
           checkVariance(sym)
           tparams foreach traverse
           vparamss foreach (_ foreach traverse)
         case Template(_, _, _, body) =>
-          super.traverse(tree)
+          foldOver((), tree)
         case _ =>
       }
     }

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

@@ -397,6 +397,28 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     ensureNoLocalRefs(assignType(cpy.Block(tree, stats1, expr1), stats1, expr1), pt)
   }
 
+  def escapingRefs(block: Block)(implicit ctx: Context): collection.Set[NamedType] = {
+    var hoisted: Set[Symbol] = Set()
+    lazy val locals = ctx.typeAssigner.localSyms(block.stats).toSet
+    def isLocal(sym: Symbol): Boolean =
+      (locals contains sym) && !isHoistableClass(sym)
+    def isHoistableClass(sym: Symbol) =
+      sym.isClass && {
+        (hoisted contains sym) || {
+          hoisted += sym
+          !classLeaks(sym.asClass)
+        }
+      }
+    def leakingTypes(tp: Type): collection.Set[NamedType] =
+      tp namedPartsWith (tp => isLocal(tp.symbol))
+    def typeLeaks(tp: Type): Boolean = leakingTypes(tp).nonEmpty
+    def classLeaks(sym: ClassSymbol): Boolean =
+      (ctx.owner is Method) || // can't hoist classes out of method bodies
+      (sym.info.parents exists typeLeaks) ||
+      (sym.decls.toList exists (t => typeLeaks(t.info)))
+    leakingTypes(block.tpe)
+  }
+
   /** Check that block's type can be expressed without references to locally defined
    *  symbols. The following two remedies are tried before giving up:
    *  1. If the expected type of the block is fully defined, pick it as the
@@ -406,7 +428,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
    */
   protected def ensureNoLocalRefs(block: Block, pt: Type, forcedDefined: Boolean = false)(implicit ctx: Context): Tree = {
     val Block(stats, expr) = block
-    val leaks = CheckTrees.escapingRefs(block)
+    val leaks = escapingRefs(block)
     if (leaks.isEmpty) block
     else if (isFullyDefined(pt, ForceDegree.all)) {
       val expr1 = Typed(expr, TypeTree(pt))