Accept untyped children of typed trees in error cases

This happens, e.g. in realApply in Applications. Change
TreeAccumulator and TreeMap to survive on untyped
tree nodes in error cases. Also, add a configurable check
that typed nodes point to untyped ones only in error cases.

Author: odersky

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -13,6 +13,7 @@ import collection.mutable.ListBuffer
 import parsing.Tokens.Token
 import printing.Printer
 import util.{Stats, Attachment, Property, DotClass}
+import config.Config
 import annotation.unchecked.uncheckedVariance
 import language.implicitConversions
 
@@ -113,10 +114,30 @@ object Trees {
      *  type. (Overridden by empty trees)
      */
     def withType(tpe: Type)(implicit ctx: Context): ThisTree[Type] = {
-      if (tpe.isInstanceOf[ErrorType]) assert(ctx.reporter.errorsReported)
+      if (tpe.isInstanceOf[ErrorType])
+        assert(ctx.reporter.errorsReported)
+      else if (Config.checkTreesConsistent)
+        checkChildrenTyped(productIterator)
       withTypeUnchecked(tpe)
     }
 
+    /** Check that typed trees don't refer to untyped ones, except if
+     *   - the parent tree is an import, or
+     *   - the child tree is an identifier, or
+     *   - errors were reported
+     */
+    private def checkChildrenTyped(it: Iterator[Any])(implicit ctx: Context): Unit =
+      if (!this.isInstanceOf[Import[_]])
+        while (it.hasNext)
+          it.next match {
+            case x: Ident[_] => // untyped idents are used in a number of places in typed trees
+            case x: Tree[_] =>
+              assert(x.hasType || ctx.reporter.errorsReported,
+                     s"$this has untyped child $x")
+            case xs: List[_] => checkChildrenTyped(xs.iterator)
+            case _ =>
+          }
+
     def withTypeUnchecked(tpe: Type): ThisTree[Type] = {
       val tree =
         (if (myTpe == null ||
@@ -1177,6 +1198,8 @@ object Trees {
           case Thicket(trees) =>
             val trees1 = transform(trees)
             if (trees1 eq trees) tree else Thicket(trees1)
+          case _ if ctx.reporter.errorsReported =>
+            tree
         }
 
       def transformStats(trees: List[Tree])(implicit ctx: Context): List[Tree] =
@@ -1282,6 +1305,9 @@ object Trees {
             this(this(x, arg), annot)
           case Thicket(ts) =>
             this(x, ts)
+          case _ if ctx.reporter.errorsReported =>
+            // in case of errors it may be that typed trees point to untyped ones.
+            x
         }
       }
     }

compiler/src/dotty/tools/dotc/config/Config.scala

@@ -72,6 +72,9 @@ object Config {
   /** Check positions for consistency after parsing */
   final val checkPositions = true
 
+  /** Check that typed trees don't point to untyped ones */
+  final val checkTreesConsistent = false
+
   /** Show subtype traces for all deep subtype recursions */
   final val traceDeepSubTypeRecursions = false
 
@@ -163,4 +166,6 @@ object Config {
    *  when findMemberLimit is set.
    */
   final val PendingFindMemberLimit = LogPendingFindMemberThreshold * 4
+
+  final val ignoreStaleInIDE = true
 }