diff options
author | Hubert Plociniczak <hubert.plociniczak@epfl.ch> | 2011-09-23 14:22:13 +0000 |
---|---|---|
committer | Hubert Plociniczak <hubert.plociniczak@epfl.ch> | 2011-09-23 14:22:13 +0000 |
commit | 1111b27d0eb95d69d7507291d242817a2dbe7e64 (patch) | |
tree | a93f609f79877a503d501e9278479a695dbca859 /src/library | |
parent | 7dc4723db3b8d435a5596db9de3e0378e023c8df (diff) | |
download | scala-1111b27d0eb95d69d7507291d242817a2dbe7e64.tar.gz scala-1111b27d0eb95d69d7507291d242817a2dbe7e64.tar.bz2 scala-1111b27d0eb95d69d7507291d242817a2dbe7e64.zip |
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.
Diffstat (limited to 'src/library')
-rw-r--r-- | src/library/scala/reflect/api/Trees.scala | 163 |
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) } |