Back to square one.

Current design of error trees complicates the design of reflection
library, and introduces sometimes unnecessary boilerplate and since I
do not want to stall that work I am reverting all the changes related
to error trees. A different design is currently under consideration but
work will be done on separate branch on github.

Revisions that got reverted:
r25705, r25704 (partially), r25673, r25669, r25649, r25644, r25621, r25620, r25619

Review by odersky and extempore.

1 files changed, 38 insertions, 125 deletions

diff --git a/src/library/scala/reflect/api/Trees.scala b/src/library/scala/reflect/api/Trees.scala
index 4606d882e3..8c13ae5da7 100644
--- a/src/library/scala/reflect/api/Trees.scala
+++ b/src/library/scala/reflect/api/Trees.scala
@@ -8,23 +8,11 @@ package api
 
 import scala.collection.mutable.ListBuffer
 
-object Trees {
-  private final val TreeIdMask   = 0x00FFFFFF
-  private final val Erroneous    = 1 << 31
-  private final val ErrorChecked = 1 << 30
-}
-import Trees._
+//import scala.tools.nsc.util.{ FreshNameCreator, HashSet, SourceFile }
 
 trait Trees /*extends reflect.generic.Trees*/ { self: Universe =>
 
-  // Pretty convenient when you need it:
-  //
-  // implicit def treeOps(tree: Tree): TreeOps
-  // type TreeOps <: {
-  //   def summaryString: String
-  // }
-
-  private[scala] var nodeCount = -1
+  private[scala] var nodeCount = 0
 
   type Modifiers <: AbsModifiers
 
@@ -88,14 +76,8 @@ trait Trees /*extends reflect.generic.Trees*/ { self: Universe =>
    *  example is Parens, which is eliminated during parsing.
    */
   abstract class Tree extends Product {
-    private[this] var treebits: Int = { nodeCount += 1; nodeCount }
-
-    def id                               = (treebits & TreeIdMask)
-    def isErrorTree                      = (treebits & Erroneous) != 0
-    def isErrorChecked                   = (treebits & ErrorChecked) != 0
-    protected final def setErrorBit()    = treebits |= Erroneous
-    protected final def setCheckedBit()  = treebits |= ErrorChecked
-    private[scala] def resetErrorBits()  = treebits = id
+    val id = nodeCount
+    nodeCount += 1
 
     private[this] var rawpos: Position = NoPosition
 
@@ -228,27 +210,12 @@ trait Trees /*extends reflect.generic.Trees*/ { self: Universe =>
       pos = tree.pos
       tpe = tree.tpe
       if (hasSymbol) symbol = tree.symbol
-      if (tree.isErrorTree) setErrorBit()
       this
     }
 
     override def toString: String = show(this)
     override def hashCode(): Int = System.identityHashCode(this)
     override def equals(that: Any) = this eq that.asInstanceOf[AnyRef]
-
-    def containsError(): Boolean = {
-      if (!isErrorChecked) {
-        for (t <- this ; if (t ne this) && t.containsError())
-          setErrorBit()
-
-        setCheckedBit()
-      }
-      isErrorTree
-    }
-  }
-
-  trait AbsErrorTree extends Tree {
-    def emit(): Unit
   }
 
   /** A tree for a term.  Not all terms are TermTrees; use isTerm
@@ -316,7 +283,6 @@ trait Trees /*extends reflect.generic.Trees*/ { self: Universe =>
        extends MemberDef {
     def name = pid.name
     def mods = Modifiers()
-
   }
 
   /** A common base class for class and object definitions.
@@ -328,15 +294,13 @@ trait Trees /*extends reflect.generic.Trees*/ { self: Universe =>
   /** A class definition.
    */
   case class ClassDef(mods: Modifiers, name: TypeName, tparams: List[TypeDef], impl: Template)
-       extends ImplDef {
-  }
+       extends ImplDef
 
   /** An object definition, e.g. `object Foo`.  Internally, objects are
    *  quite frequently called modules to reduce ambiguity.
    */
   case class ModuleDef(mods: Modifiers, name: TermName, impl: Template)
-       extends ImplDef {
-  }
+       extends ImplDef
 
   /** A common base class for ValDefs and DefDefs.
    */
@@ -349,20 +313,17 @@ trait Trees /*extends reflect.generic.Trees*/ { self: Universe =>
   /** A value definition (this includes vars as well, which differ from
    *  vals only in having the MUTABLE flag set in their Modifiers.)
    */
-  case class ValDef(mods: Modifiers, name: TermName, tpt: Tree, rhs: Tree) extends ValOrDefDef {
-  }
+  case class ValDef(mods: Modifiers, name: TermName, tpt: Tree, rhs: Tree) extends ValOrDefDef
 
   /** A method definition.
    */
   case class DefDef(mods: Modifiers, name: TermName, tparams: List[TypeDef],
-                    vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree) extends ValOrDefDef {
-  }
+                    vparamss: List[List[ValDef]], tpt: Tree, rhs: Tree) extends ValOrDefDef
 
   /** An abstract type, a type parameter, or a type alias.
    */
   case class TypeDef(mods: Modifiers, name: TypeName, tparams: List[TypeDef], rhs: Tree)
-       extends MemberDef {
-  }
+       extends MemberDef
 
   /** A labelled expression.  Not expressible in language syntax, but
    *  generated by the compiler to simulate while/do-while loops, and
@@ -379,8 +340,7 @@ trait Trees /*extends reflect.generic.Trees*/ { self: Universe =>
    *  Forward jumps within a block are allowed.
    */
   case class LabelDef(name: TermName, params: List[Ident], rhs: Tree)
-       extends DefTree with TermTree {
-  }
+       extends DefTree with TermTree
 
   /** Import selector
    *
@@ -399,8 +359,7 @@ trait Trees /*extends reflect.generic.Trees*/ { self: Universe =>
    *  @param selectors
    */
   case class Import(expr: Tree, selectors: List[ImportSelector])
-       extends SymTree {
-  }
+       extends SymTree
     // The symbol of an Import is an import symbol @see Symbol.newImport
     // It's used primarily as a marker to check that the import has been typechecked.
 
@@ -426,27 +385,23 @@ trait Trees /*extends reflect.generic.Trees*/ { self: Universe =>
 
   /** Block of expressions (semicolon separated expressions) */
   case class Block(stats: List[Tree], expr: Tree)
-       extends TermTree {
-  }
+       extends TermTree
 
   /** Case clause in a pattern match, eliminated during explicitouter
    *  (except for occurrences in switch statements)
    */
   case class CaseDef(pat: Tree, guard: Tree, body: Tree)
-       extends Tree {
-  }
+       extends Tree
 
   /** Alternatives of patterns, eliminated by explicitouter, except for
    *  occurrences in encoded Switch stmt (=remaining Match(CaseDef(...))
    */
   case class Alternative(trees: List[Tree])
-       extends TermTree {
-  }
+       extends TermTree
 
   /** Repetition of pattern, eliminated by explicitouter */
   case class Star(elem: Tree)
-       extends TermTree {
-  }
+       extends TermTree
 
   /** Bind of a variable to a rhs pattern, eliminated by explicitouter
    *
@@ -454,35 +409,29 @@ trait Trees /*extends reflect.generic.Trees*/ { self: Universe =>
    *  @param body
    */
   case class Bind(name: Name, body: Tree)
-       extends DefTree {
-  }
+       extends DefTree
 
   case class UnApply(fun: Tree, args: List[Tree])
-       extends TermTree {
-  }
+       extends TermTree
 
   /** Array of expressions, needs to be translated in backend,
    */
   case class ArrayValue(elemtpt: Tree, elems: List[Tree])
-       extends TermTree {
-  }
+       extends TermTree
 
   /** Anonymous function, eliminated by analyzer */
   case class Function(vparams: List[ValDef], body: Tree)
-       extends TermTree with SymTree  {
-  }
+       extends TermTree with SymTree
     // The symbol of a Function is a synthetic value of name nme.ANON_FUN_NAME
     // It is the owner of the function's parameters.
 
   /** Assignment */
   case class Assign(lhs: Tree, rhs: Tree)
-       extends TermTree {
-  }
+       extends TermTree
 
   /** Conditional expression */
   case class If(cond: Tree, thenp: Tree, elsep: Tree)
-       extends TermTree {
-  }
+       extends TermTree
 
   /** - Pattern matching expression  (before explicitouter)
    *  - Switch statements            (after explicitouter)
@@ -496,36 +445,30 @@ trait Trees /*extends reflect.generic.Trees*/ { self: Universe =>
    *    `Ident(nme.WILDCARD)`
    */
   case class Match(selector: Tree, cases: List[CaseDef])
-       extends TermTree {
-  }
+       extends TermTree
 
   /** Return expression */
   case class Return(expr: Tree)
-       extends TermTree with SymTree {
-  }
+       extends TermTree with SymTree
     // The symbol of a Return node is the enclosing method.
 
   case class Try(block: Tree, catches: List[CaseDef], finalizer: Tree)
-       extends TermTree {
-  }
+       extends TermTree
 
   /** Throw expression */
   case class Throw(expr: Tree)
-       extends TermTree {
-  }
+       extends TermTree
 
   /** Object instantiation
    *  One should always use factory method below to build a user level new.
    *
    *  @param tpt    a class type
    */
-  case class New(tpt: Tree) extends TermTree {
-  }
+  case class New(tpt: Tree) extends TermTree
 
   /** Type annotation, eliminated by explicit outer */
   case class Typed(expr: Tree, tpt: Tree)
-       extends TermTree {
-  }
+       extends TermTree
 
   /** Common base class for Apply and TypeApply. This could in principle
    *  be a SymTree, but whether or not a Tree is a SymTree isn't used
@@ -544,7 +487,6 @@ trait Trees /*extends reflect.generic.Trees*/ { self: Universe =>
        extends GenericApply {
     override def symbol: Symbol = fun.symbol
     override def symbol_=(sym: Symbol) { fun.symbol = sym }
-
   }
 
   /** Value application */
@@ -552,7 +494,6 @@ trait Trees /*extends reflect.generic.Trees*/ { self: Universe =>
        extends GenericApply {
     override def symbol: Symbol = fun.symbol
     override def symbol_=(sym: Symbol) { fun.symbol = sym }
-
   }
 
   class ApplyToImplicitArgs(fun: Tree, args: List[Tree]) extends Apply(fun, args)
@@ -566,8 +507,7 @@ trait Trees /*extends reflect.generic.Trees*/ { self: Universe =>
    *   - f is stored as the node's symbol field.
    */
   case class ApplyDynamic(qual: Tree, args: List[Tree])
-       extends TermTree with SymTree {
-  }
+       extends TermTree with SymTree
     // The symbol of an ApplyDynamic is the function symbol of `qual`, or NoSymbol, if there is none.
 
   /** Super reference, qual = corresponding this reference */
@@ -576,25 +516,20 @@ trait Trees /*extends reflect.generic.Trees*/ { self: Universe =>
     // For instance in C.super(...), it would be C.
     override def symbol: Symbol = qual.symbol
     override def symbol_=(sym: Symbol) { qual.symbol = sym }
-
   }
 
   /** Self reference */
   case class This(qual: TypeName)
-        extends TermTree with SymTree {
-    // TODO should check qual name, symbol?
-  }
+        extends TermTree with SymTree
     // The symbol of a This is the class to which the this refers.
     // For instance in C.this, it would be C.
 
   /** Designator <qualifier> . <name> */
   case class Select(qualifier: Tree, name: Name)
-       extends RefTree {
-  }
+       extends RefTree
 
   /** Identifier <name> */
-  case class Ident(name: Name) extends RefTree {
-  }
+  case class Ident(name: Name) extends RefTree { }
 
   class BackQuotedIdent(name: Name) extends Ident(name)
 
@@ -612,54 +547,40 @@ trait Trees /*extends reflect.generic.Trees*/ { self: Universe =>
    *  Eliminated by typechecker (typedAnnotated), the annotations are then stored in
    *  an AnnotatedType.
    */
-  case class Annotated(annot: Tree, arg: Tree) extends Tree {
-  }
+  case class Annotated(annot: Tree, arg: Tree) extends Tree
 
   /** Singleton type, eliminated by RefCheck */
   case class SingletonTypeTree(ref: Tree)
-        extends TypTree {
-
-  }
+        extends TypTree
 
   /** Type selection <qualifier> # <name>, eliminated by RefCheck */
   case class SelectFromTypeTree(qualifier: Tree, name: TypeName)
-       extends TypTree with RefTree {
-  }
+       extends TypTree with RefTree
 
   /** Intersection type <parent1> with ... with <parentN> { <decls> }, eliminated by RefCheck */
   case class CompoundTypeTree(templ: Template)
-       extends TypTree {
-
-  }
+       extends TypTree
 
   /** Applied type <tpt> [ <args> ], eliminated by RefCheck */
   case class AppliedTypeTree(tpt: Tree, args: List[Tree])
        extends TypTree {
     override def symbol: Symbol = tpt.symbol
     override def symbol_=(sym: Symbol) { tpt.symbol = sym }
-
   }
 
   case class TypeBoundsTree(lo: Tree, hi: Tree)
-       extends TypTree {
-
-  }
+       extends TypTree
 
   case class ExistentialTypeTree(tpt: Tree, whereClauses: List[Tree])
-       extends TypTree {
-
-  }
+       extends TypTree
 
   /** A synthetic tree holding an arbitrary type.  Not to be confused with
     * with TypTree, the trait for trees that are only used for type trees.
     * TypeTree's are inserted in several places, but most notably in
     * `RefCheck`, where the arbitrary type trees are all replaced by
-    * TypeTree's.
-    *
-    */
+    * TypeTree's. */
   case class TypeTree() extends TypTree {
     private var orig: Tree = null
-    private var errorCause: Tree = null
     private[scala] var wasEmpty: Boolean = false
 
     override def symbol = if (tpe == null) null else tpe.typeSymbol
@@ -676,13 +597,6 @@ trait Trees /*extends reflect.generic.Trees*/ { self: Universe =>
       this
     }
 
-    def setErrorCause(tree: Tree): this.type = {
-      assert(tree != null)
-      errorCause = tree
-      setErrorBit()
-      this
-    }
-
     override def defineType(tp: Type): this.type = {
       wasEmpty = isEmpty
       setType(tp)
@@ -800,7 +714,6 @@ trait Trees /*extends reflect.generic.Trees*/ { self: Universe =>
         traverse(lo); traverse(hi)
       case ExistentialTypeTree(tpt, whereClauses) =>
         traverse(tpt); traverseTrees(whereClauses)
-      case _: AbsErrorTree =>
       case _ => xtraverse(this, tree)
     }