Revert: Add tag method to Tree nodes

(reverted from commit 0934483)

Author: odersky

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

@@ -19,82 +19,6 @@ import language.implicitConversions
 
 object Trees {
 
-  type TreeTag = Int
-
-  object Tag {
-    final val Ident = 0
-    final val Select = 1
-    final val This = 2
-    final val Super = 3
-    final val Apply = 4
-    final val TypeApply = 5
-    final val Literal = 6
-    final val New = 7
-    final val Typed = 8
-    final val NamedArg = 9
-    final val Assign = 10
-    final val Block = 11
-    final val If = 12
-    final val Closure = 13
-    final val Match = 14
-    final val CaseDef = 15
-    final val Return = 16
-    final val Try = 17
-    final val SeqLiteral = 18
-    final val Inlined = 19
-    final val TypeTree = 20
-    final val Bind = 21
-    final val Alternative = 22
-    final val UnApply = 23
-    final val ValDef = 24
-    final val DefDef = 25
-    final val TypeDef = 26
-    final val Template = 27
-    final val Import = 28
-    final val PackageDef = 29
-    final val Thicket = 30
-
-    /** The highest tree tag that can appear in a picked tree + 1 */
-    final val NumPickledTreeTags = 31
-
-    final val Annotated = 31
-    final val SingletonTypeTree = 32
-    final val AndTypeTree = 33
-    final val OrTypeTree = 34
-    final val RefinedTypeTree = 35
-    final val AppliedTypeTree = 36
-    final val LambdaTypeTree = 37
-    final val ByNameTypeTree = 38
-    final val TypeBoundsTree = 39
-
-    /** The highest tree tag that can appear in a typed tree + 1 */
-    final val NumTypedTreeTags = 40
-
-    final val TypedSplice = 40
-    final val ModuleDef = 41
-    final val ParsedTry = 42
-    final val SymbolLit = 43
-    final val InterpolatedString = 44
-    final val Function = 45
-    final val InfixOp = 46
-    final val PostfixOp = 47
-    final val PrefixOp = 48
-    final val Parens = 49
-    final val Tuple = 50
-    final val Throw = 51
-    final val WhileDo = 42
-    final val DoWhile = 43
-    final val ForYield = 44
-    final val ForDo = 45
-    final val GenFrom = 46
-    final val GenAlias = 47
-    final val ContextBounds = 48
-    final val PatDef = 49
-
-    /** The highest tree tag + 1 */
-    final val NumTags = 50
-  }
-
   // Note: it would be more logical to make Untyped = Nothing.
   // However, this interacts in a bad way with Scala's current type inference.
   // In fact, we cannot write something like Select(pre, name), where pre is
@@ -154,8 +78,6 @@ object Trees {
     /** The type  constructor at the root of the tree */
     type ThisTree[T >: Untyped] <: Tree[T]
 
-    def tag: TreeTag
-
     private[this] var myTpe: T = _
 
     /** Destructively set the type of the tree. This should be called only when it is known that
@@ -435,7 +357,6 @@ object Trees {
   case class Ident[-T >: Untyped] private[ast] (name: Name)
     extends RefTree[T] {
     type ThisTree[-T >: Untyped] = Ident[T]
-    final def tag = Tag.Ident
     def qualifier: Tree[T] = genericEmptyTree
 
     /** Is this a `BackquotedIdent` ? */
@@ -453,7 +374,6 @@ object Trees {
   case class Select[-T >: Untyped] private[ast] (qualifier: Tree[T], name: Name)
     extends RefTree[T] {
     type ThisTree[-T >: Untyped] = Select[T]
-    final def tag = Tag.Select
   }
 
   class SelectWithSig[-T >: Untyped] private[ast] (qualifier: Tree[T], name: Name, val sig: Signature)
@@ -465,7 +385,6 @@ object Trees {
   case class This[-T >: Untyped] private[ast] (qual: untpd.Ident)
     extends DenotingTree[T] with TermTree[T] {
     type ThisTree[-T >: Untyped] = This[T]
-    final def tag = Tag.This
     // Denotation of a This tree is always the underlying class; needs correction for modules.
     override def denot(implicit ctx: Context): Denotation = {
       typeOpt match {
@@ -481,7 +400,6 @@ object Trees {
   case class Super[-T >: Untyped] private[ast] (qual: Tree[T], mix: untpd.Ident)
     extends ProxyTree[T] with TermTree[T] {
     type ThisTree[-T >: Untyped] = Super[T]
-    final def tag = Tag.Super
     def forwardTo = qual
   }
 
@@ -496,64 +414,55 @@ object Trees {
   case class Apply[-T >: Untyped] private[ast] (fun: Tree[T], args: List[Tree[T]])
     extends GenericApply[T] {
     type ThisTree[-T >: Untyped] = Apply[T]
-    final def tag = Tag.Apply
   }
 
   /** fun[args] */
   case class TypeApply[-T >: Untyped] private[ast] (fun: Tree[T], args: List[Tree[T]])
     extends GenericApply[T] {
     type ThisTree[-T >: Untyped] = TypeApply[T]
-    final def tag = Tag.TypeApply
   }
 
   /** const */
   case class Literal[-T >: Untyped] private[ast] (const: Constant)
     extends TermTree[T] {
     type ThisTree[-T >: Untyped] = Literal[T]
-    final def tag = Tag.Literal
   }
 
   /** new tpt, but no constructor call */
   case class New[-T >: Untyped] private[ast] (tpt: Tree[T])
     extends TermTree[T] {
     type ThisTree[-T >: Untyped] = New[T]
-    final def tag = Tag.New
   }
 
   /** expr : tpt */
   case class Typed[-T >: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])
     extends ProxyTree[T] with TermTree[T] {
     type ThisTree[-T >: Untyped] = Typed[T]
-    final def tag = Tag.Typed
     def forwardTo = expr
   }
 
   /** name = arg, in a parameter list */
   case class NamedArg[-T >: Untyped] private[ast] (name: Name, arg: Tree[T])
     extends Tree[T] {
     type ThisTree[-T >: Untyped] = NamedArg[T]
-    final def tag = Tag.NamedArg
   }
 
   /** name = arg, outside a parameter list */
   case class Assign[-T >: Untyped] private[ast] (lhs: Tree[T], rhs: Tree[T])
     extends TermTree[T] {
     type ThisTree[-T >: Untyped] = Assign[T]
-    final def tag = Tag.Assign
   }
 
   /** { stats; expr } */
   case class Block[-T >: Untyped] private[ast] (stats: List[Tree[T]], expr: Tree[T])
     extends TermTree[T] {
     type ThisTree[-T >: Untyped] = Block[T]
-    final def tag = Tag.Block
   }
 
   /** if cond then thenp else elsep */
   case class If[-T >: Untyped] private[ast] (cond: Tree[T], thenp: Tree[T], elsep: Tree[T])
     extends TermTree[T] {
     type ThisTree[-T >: Untyped] = If[T]
-    final def tag = Tag.If
   }
 
   /** A closure with an environment and a reference to a method.
@@ -568,21 +477,18 @@ object Trees {
   case class Closure[-T >: Untyped] private[ast] (env: List[Tree[T]], meth: Tree[T], tpt: Tree[T])
     extends TermTree[T] {
     type ThisTree[-T >: Untyped] = Closure[T]
-    final def tag = Tag.Closure
   }
 
   /** selector match { cases } */
   case class Match[-T >: Untyped] private[ast] (selector: Tree[T], cases: List[CaseDef[T]])
     extends TermTree[T] {
     type ThisTree[-T >: Untyped] = Match[T]
-    final def tag = Tag.Match
   }
 
   /** case pat if guard => body; only appears as child of a Match */
   case class CaseDef[-T >: Untyped] private[ast] (pat: Tree[T], guard: Tree[T], body: Tree[T])
     extends Tree[T] {
     type ThisTree[-T >: Untyped] = CaseDef[T]
-    final def tag = Tag.CaseDef
   }
 
   /** return expr
@@ -593,7 +499,6 @@ object Trees {
   case class Return[-T >: Untyped] private[ast] (expr: Tree[T], from: Tree[T] = genericEmptyTree)
     extends TermTree[T] {
     type ThisTree[-T >: Untyped] = Return[T]
-    final def tag = Tag.Return
   }
 
   /** try block catch handler finally finalizer
@@ -618,7 +523,6 @@ object Trees {
   case class Try[-T >: Untyped] private[ast] (expr: Tree[T], cases: List[CaseDef[T]], finalizer: Tree[T])
     extends TermTree[T] {
     type ThisTree[-T >: Untyped] = Try[T]
-    final def tag = Tag.Try
   }
 
   /** Seq(elems)
@@ -627,7 +531,6 @@ object Trees {
   case class SeqLiteral[-T >: Untyped] private[ast] (elems: List[Tree[T]], elemtpt: Tree[T])
     extends Tree[T] {
     type ThisTree[-T >: Untyped] = SeqLiteral[T]
-    final def tag = Tag.SeqLiteral
   }
 
   /** Array(elems) */
@@ -655,14 +558,12 @@ object Trees {
   case class Inlined[-T >: Untyped] private[ast] (call: tpd.Tree, bindings: List[MemberDef[T]], expansion: Tree[T])
     extends Tree[T] {
     type ThisTree[-T >: Untyped] = Inlined[T]
-    final def tag = Tag.Inlined
   }
 
   /** A type tree that represents an existing or inferred type */
   case class TypeTree[-T >: Untyped] ()
     extends DenotingTree[T] with TypTree[T] {
     type ThisTree[-T >: Untyped] = TypeTree[T]
-    final def tag = Tag.TypeTree
     override def isEmpty = !hasType
     override def toString =
       s"TypeTree${if (hasType) s"[$typeOpt]" else ""}"
@@ -672,65 +573,56 @@ object Trees {
   case class SingletonTypeTree[-T >: Untyped] private[ast] (ref: Tree[T])
     extends DenotingTree[T] with TypTree[T] {
     type ThisTree[-T >: Untyped] = SingletonTypeTree[T]
-    final def tag = Tag.SingletonTypeTree
   }
 
   /** left & right */
   case class AndTypeTree[-T >: Untyped] private[ast] (left: Tree[T], right: Tree[T])
     extends TypTree[T] {
     type ThisTree[-T >: Untyped] = AndTypeTree[T]
-    final def tag = Tag.AndTypeTree
   }
 
   /** left | right */
   case class OrTypeTree[-T >: Untyped] private[ast] (left: Tree[T], right: Tree[T])
     extends TypTree[T] {
     type ThisTree[-T >: Untyped] = OrTypeTree[T]
-    final def tag = Tag.OrTypeTree
   }
 
   /** tpt { refinements } */
   case class RefinedTypeTree[-T >: Untyped] private[ast] (tpt: Tree[T], refinements: List[Tree[T]])
     extends ProxyTree[T] with TypTree[T] {
     type ThisTree[-T >: Untyped] = RefinedTypeTree[T]
-    final def tag = Tag.RefinedTypeTree
     def forwardTo = tpt
   }
 
   /** tpt[args] */
   case class AppliedTypeTree[-T >: Untyped] private[ast] (tpt: Tree[T], args: List[Tree[T]])
     extends ProxyTree[T] with TypTree[T] {
     type ThisTree[-T >: Untyped] = AppliedTypeTree[T]
-    final def tag = Tag.AppliedTypeTree
     def forwardTo = tpt
   }
 
   /** [typeparams] -> tpt */
   case class LambdaTypeTree[-T >: Untyped] private[ast] (tparams: List[TypeDef[T]], body: Tree[T])
     extends TypTree[T] {
     type ThisTree[-T >: Untyped] = LambdaTypeTree[T]
-    final def tag = Tag.LambdaTypeTree
   }
 
   /** => T */
   case class ByNameTypeTree[-T >: Untyped] private[ast] (result: Tree[T])
   extends TypTree[T] {
     type ThisTree[-T >: Untyped] = ByNameTypeTree[T]
-    final def tag = Tag.ByNameTypeTree
   }
 
   /** >: lo <: hi */
   case class TypeBoundsTree[-T >: Untyped] private[ast] (lo: Tree[T], hi: Tree[T])
     extends TypTree[T] {
     type ThisTree[-T >: Untyped] = TypeBoundsTree[T]
-    final def tag = Tag.TypeBoundsTree
   }
 
   /** name @ body */
   case class Bind[-T >: Untyped] private[ast] (name: Name, body: Tree[T])
     extends NameTree[T] with DefTree[T] with PatternTree[T] {
     type ThisTree[-T >: Untyped] = Bind[T]
-    final def tag = Tag.Bind
     override def isType = name.isTypeName
     override def isTerm = name.isTermName
   }
@@ -739,7 +631,6 @@ object Trees {
   case class Alternative[-T >: Untyped] private[ast] (trees: List[Tree[T]])
     extends PatternTree[T] {
     type ThisTree[-T >: Untyped] = Alternative[T]
-    final def tag = Tag.Alternative
   }
 
   /** The typed translation of `extractor(patterns)` in a pattern. The translation has the following
@@ -759,14 +650,12 @@ object Trees {
   case class UnApply[-T >: Untyped] private[ast] (fun: Tree[T], implicits: List[Tree[T]], patterns: List[Tree[T]])
     extends PatternTree[T] {
     type ThisTree[-T >: Untyped] = UnApply[T]
-    final def tag = Tag.UnApply
   }
 
   /** mods val name: tpt = rhs */
   case class ValDef[-T >: Untyped] private[ast] (name: TermName, tpt: Tree[T], private var preRhs: LazyTree)
     extends ValOrDefDef[T] {
     type ThisTree[-T >: Untyped] = ValDef[T]
-    final def tag = Tag.ValDef
     assert(isEmpty || tpt != genericEmptyTree)
     def unforced = preRhs
     protected def force(x: AnyRef) = preRhs = x
@@ -777,7 +666,6 @@ object Trees {
       vparamss: List[List[ValDef[T]]], tpt: Tree[T], private var preRhs: LazyTree)
     extends ValOrDefDef[T] {
     type ThisTree[-T >: Untyped] = DefDef[T]
-    final def tag = Tag.DefDef
     assert(tpt != genericEmptyTree)
     def unforced = preRhs
     protected def force(x: AnyRef) = preRhs = x
@@ -791,7 +679,6 @@ object Trees {
   case class TypeDef[-T >: Untyped] private[ast] (name: TypeName, rhs: Tree[T])
     extends MemberDef[T] {
     type ThisTree[-T >: Untyped] = TypeDef[T]
-    final def tag = Tag.TypeDef
 
     /** Is this a definition of a class? */
     def isClassDef = rhs.isInstanceOf[Template[_]]
@@ -801,7 +688,6 @@ object Trees {
   case class Template[-T >: Untyped] private[ast] (constr: DefDef[T], parents: List[Tree[T]], self: ValDef[T], private var preBody: LazyTreeList)
     extends DefTree[T] with WithLazyField[List[Tree[T]]] {
     type ThisTree[-T >: Untyped] = Template[T]
-    final def tag = Tag.Template
     def unforcedBody = unforced
     def unforced = preBody
     protected def force(x: AnyRef) = preBody = x
@@ -815,22 +701,19 @@ object Trees {
   case class Import[-T >: Untyped] private[ast] (expr: Tree[T], selectors: List[Tree[Untyped]])
     extends DenotingTree[T] {
     type ThisTree[-T >: Untyped] = Import[T]
-    final def tag = Tag.Import
   }
 
   /** package pid { stats } */
   case class PackageDef[-T >: Untyped] private[ast] (pid: RefTree[T], stats: List[Tree[T]])
     extends ProxyTree[T] {
     type ThisTree[-T >: Untyped] = PackageDef[T]
-    final def tag = Tag.PackageDef
     def forwardTo = pid
   }
 
   /** arg @annot */
   case class Annotated[-T >: Untyped] private[ast] (arg: Tree[T], annot: Tree[T])
     extends ProxyTree[T] {
     type ThisTree[-T >: Untyped] = Annotated[T]
-    final def tag = Tag.Annotated
     def forwardTo = arg
   }
 
@@ -849,7 +732,6 @@ object Trees {
   case class Thicket[-T >: Untyped](trees: List[Tree[T]])
     extends Tree[T] with WithoutTypeOrPos[T] {
     type ThisTree[-T >: Untyped] = Thicket[T]
-    final def tag = Tag.Thicket
     override def isEmpty: Boolean = trees.isEmpty
     override def toList: List[Tree[T]] = flatten(trees)
     override def toString = if (isEmpty) "EmptyTree" else "Thicket(" + trees.mkString(", ") + ")"