Skip to content

Commit 0934483

Browse files
committed
Add tag method to Tree nodes
1 parent 1ee4d1e commit 0934483

File tree

2 files changed

+158
-15
lines changed

2 files changed

+158
-15
lines changed

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

Lines changed: 108 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,72 @@ import language.implicitConversions
1919

2020
object Trees {
2121

22+
type TreeTag = Int
23+
24+
object Tag {
25+
final val Ident = 0
26+
final val Select = 1
27+
final val This = 2
28+
final val Super = 3
29+
final val Apply = 4
30+
final val TypeApply = 5
31+
final val Literal = 6
32+
final val New = 7
33+
final val Typed = 8
34+
final val NamedArg = 9
35+
final val Assign = 10
36+
final val Block = 11
37+
final val If = 12
38+
final val Closure = 13
39+
final val Match = 14
40+
final val CaseDef = 15
41+
final val Return = 16
42+
final val Try = 17
43+
final val SeqLiteral = 18
44+
final val Inlined = 19
45+
final val TypeTree = 20
46+
final val SingletonTypeTree = 21
47+
final val AndTypeTree = 22
48+
final val OrTypeTree = 23
49+
final val RefinedTypeTree = 24
50+
final val AppliedTypeTree = 25
51+
final val LambdaTypeTree = 26
52+
final val ByNameTypeTree = 27
53+
final val TypeBoundsTree = 28
54+
final val Bind = 29
55+
final val Alternative = 30
56+
final val UnApply = 31
57+
final val ValDef = 32
58+
final val DefDef = 33
59+
final val TypeDef = 34
60+
final val Template = 35
61+
final val Import = 36
62+
final val PackageDef = 37
63+
final val Annotated = 38
64+
final val Thicket = 39
65+
66+
final val TypedSplice = 40
67+
final val ModuleDef = 41
68+
final val ParsedTry = 42
69+
final val SymbolLit = 43
70+
final val InterpolatedString = 44
71+
final val Function = 45
72+
final val InfixOp = 46
73+
final val PostfixOp = 47
74+
final val PrefixOp = 48
75+
final val Parens = 49
76+
final val Tuple = 50
77+
final val Throw = 51
78+
final val WhileDo = 42
79+
final val DoWhile = 43
80+
final val ForYield = 44
81+
final val ForDo = 45
82+
final val GenFrom = 46
83+
final val GenAlias = 47
84+
final val ContextBounds = 48
85+
final val PatDef = 49
86+
}
87+
2288
// Note: it would be more logical to make Untyped = Nothing.
2389
// However, this interacts in a bad way with Scala's current type inference.
2490
// In fact, we cannot write something like Select(pre, name), where pre is
@@ -78,6 +144,8 @@ object Trees {
78144
/** The type constructor at the root of the tree */
79145
type ThisTree[T >: Untyped] <: Tree[T]
80146

147+
def tag: TreeTag
148+
81149
private[this] var myTpe: T = _
82150

83151
/** Destructively set the type of the tree. This should be called only when it is known that
@@ -357,6 +425,7 @@ object Trees {
357425
case class Ident[-T >: Untyped] private[ast] (name: Name)
358426
extends RefTree[T] {
359427
type ThisTree[-T >: Untyped] = Ident[T]
428+
def tag = Tag.Ident
360429
def qualifier: Tree[T] = genericEmptyTree
361430

362431
/** Is this a `BackquotedIdent` ? */
@@ -374,6 +443,7 @@ object Trees {
374443
case class Select[-T >: Untyped] private[ast] (qualifier: Tree[T], name: Name)
375444
extends RefTree[T] {
376445
type ThisTree[-T >: Untyped] = Select[T]
446+
def tag = Tag.Select
377447
}
378448

379449
class SelectWithSig[-T >: Untyped] private[ast] (qualifier: Tree[T], name: Name, val sig: Signature)
@@ -385,6 +455,7 @@ object Trees {
385455
case class This[-T >: Untyped] private[ast] (qual: untpd.Ident)
386456
extends DenotingTree[T] with TermTree[T] {
387457
type ThisTree[-T >: Untyped] = This[T]
458+
def tag = Tag.This
388459
// Denotation of a This tree is always the underlying class; needs correction for modules.
389460
override def denot(implicit ctx: Context): Denotation = {
390461
typeOpt match {
@@ -400,6 +471,7 @@ object Trees {
400471
case class Super[-T >: Untyped] private[ast] (qual: Tree[T], mix: untpd.Ident)
401472
extends ProxyTree[T] with TermTree[T] {
402473
type ThisTree[-T >: Untyped] = Super[T]
474+
def tag = Tag.Super
403475
def forwardTo = qual
404476
}
405477

@@ -414,55 +486,64 @@ object Trees {
414486
case class Apply[-T >: Untyped] private[ast] (fun: Tree[T], args: List[Tree[T]])
415487
extends GenericApply[T] {
416488
type ThisTree[-T >: Untyped] = Apply[T]
489+
def tag = Tag.Apply
417490
}
418491

419492
/** fun[args] */
420493
case class TypeApply[-T >: Untyped] private[ast] (fun: Tree[T], args: List[Tree[T]])
421494
extends GenericApply[T] {
422495
type ThisTree[-T >: Untyped] = TypeApply[T]
496+
def tag = Tag.TypeApply
423497
}
424498

425499
/** const */
426500
case class Literal[-T >: Untyped] private[ast] (const: Constant)
427501
extends TermTree[T] {
428502
type ThisTree[-T >: Untyped] = Literal[T]
503+
def tag = Tag.Literal
429504
}
430505

431506
/** new tpt, but no constructor call */
432507
case class New[-T >: Untyped] private[ast] (tpt: Tree[T])
433508
extends TermTree[T] {
434509
type ThisTree[-T >: Untyped] = New[T]
510+
def tag = Tag.New
435511
}
436512

437513
/** expr : tpt */
438514
case class Typed[-T >: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])
439515
extends ProxyTree[T] with TermTree[T] {
440516
type ThisTree[-T >: Untyped] = Typed[T]
517+
def tag = Tag.Typed
441518
def forwardTo = expr
442519
}
443520

444521
/** name = arg, in a parameter list */
445522
case class NamedArg[-T >: Untyped] private[ast] (name: Name, arg: Tree[T])
446523
extends Tree[T] {
447524
type ThisTree[-T >: Untyped] = NamedArg[T]
525+
def tag = Tag.NamedArg
448526
}
449527

450528
/** name = arg, outside a parameter list */
451529
case class Assign[-T >: Untyped] private[ast] (lhs: Tree[T], rhs: Tree[T])
452530
extends TermTree[T] {
453531
type ThisTree[-T >: Untyped] = Assign[T]
532+
def tag = Tag.Assign
454533
}
455534

456535
/** { stats; expr } */
457536
case class Block[-T >: Untyped] private[ast] (stats: List[Tree[T]], expr: Tree[T])
458537
extends TermTree[T] {
459538
type ThisTree[-T >: Untyped] = Block[T]
539+
def tag = Tag.Block
460540
}
461541

462542
/** if cond then thenp else elsep */
463543
case class If[-T >: Untyped] private[ast] (cond: Tree[T], thenp: Tree[T], elsep: Tree[T])
464544
extends TermTree[T] {
465545
type ThisTree[-T >: Untyped] = If[T]
546+
def tag = Tag.If
466547
}
467548

468549
/** A closure with an environment and a reference to a method.
@@ -477,18 +558,21 @@ object Trees {
477558
case class Closure[-T >: Untyped] private[ast] (env: List[Tree[T]], meth: Tree[T], tpt: Tree[T])
478559
extends TermTree[T] {
479560
type ThisTree[-T >: Untyped] = Closure[T]
561+
def tag = Tag.Closure
480562
}
481563

482564
/** selector match { cases } */
483565
case class Match[-T >: Untyped] private[ast] (selector: Tree[T], cases: List[CaseDef[T]])
484566
extends TermTree[T] {
485567
type ThisTree[-T >: Untyped] = Match[T]
568+
def tag = Tag.Match
486569
}
487570

488571
/** case pat if guard => body; only appears as child of a Match */
489572
case class CaseDef[-T >: Untyped] private[ast] (pat: Tree[T], guard: Tree[T], body: Tree[T])
490573
extends Tree[T] {
491574
type ThisTree[-T >: Untyped] = CaseDef[T]
575+
def tag = Tag.CaseDef
492576
}
493577

494578
/** return expr
@@ -499,6 +583,7 @@ object Trees {
499583
case class Return[-T >: Untyped] private[ast] (expr: Tree[T], from: Tree[T] = genericEmptyTree)
500584
extends TermTree[T] {
501585
type ThisTree[-T >: Untyped] = Return[T]
586+
def tag = Tag.Return
502587
}
503588

504589
/** try block catch handler finally finalizer
@@ -523,6 +608,7 @@ object Trees {
523608
case class Try[-T >: Untyped] private[ast] (expr: Tree[T], cases: List[CaseDef[T]], finalizer: Tree[T])
524609
extends TermTree[T] {
525610
type ThisTree[-T >: Untyped] = Try[T]
611+
def tag = Tag.Try
526612
}
527613

528614
/** Seq(elems)
@@ -531,6 +617,7 @@ object Trees {
531617
case class SeqLiteral[-T >: Untyped] private[ast] (elems: List[Tree[T]], elemtpt: Tree[T])
532618
extends Tree[T] {
533619
type ThisTree[-T >: Untyped] = SeqLiteral[T]
620+
def tag = Tag.SeqLiteral
534621
}
535622

536623
/** Array(elems) */
@@ -558,12 +645,14 @@ object Trees {
558645
case class Inlined[-T >: Untyped] private[ast] (call: tpd.Tree, bindings: List[MemberDef[T]], expansion: Tree[T])
559646
extends Tree[T] {
560647
type ThisTree[-T >: Untyped] = Inlined[T]
648+
def tag = Tag.Inlined
561649
}
562650

563651
/** A type tree that represents an existing or inferred type */
564652
case class TypeTree[-T >: Untyped] ()
565653
extends DenotingTree[T] with TypTree[T] {
566654
type ThisTree[-T >: Untyped] = TypeTree[T]
655+
def tag = Tag.TypeTree
567656
override def isEmpty = !hasType
568657
override def toString =
569658
s"TypeTree${if (hasType) s"[$typeOpt]" else ""}"
@@ -573,56 +662,65 @@ object Trees {
573662
case class SingletonTypeTree[-T >: Untyped] private[ast] (ref: Tree[T])
574663
extends DenotingTree[T] with TypTree[T] {
575664
type ThisTree[-T >: Untyped] = SingletonTypeTree[T]
665+
def tag = Tag.SingletonTypeTree
576666
}
577667

578668
/** left & right */
579669
case class AndTypeTree[-T >: Untyped] private[ast] (left: Tree[T], right: Tree[T])
580670
extends TypTree[T] {
581671
type ThisTree[-T >: Untyped] = AndTypeTree[T]
672+
def tag = Tag.AndTypeTree
582673
}
583674

584675
/** left | right */
585676
case class OrTypeTree[-T >: Untyped] private[ast] (left: Tree[T], right: Tree[T])
586677
extends TypTree[T] {
587678
type ThisTree[-T >: Untyped] = OrTypeTree[T]
679+
def tag = Tag.OrTypeTree
588680
}
589681

590682
/** tpt { refinements } */
591683
case class RefinedTypeTree[-T >: Untyped] private[ast] (tpt: Tree[T], refinements: List[Tree[T]])
592684
extends ProxyTree[T] with TypTree[T] {
593685
type ThisTree[-T >: Untyped] = RefinedTypeTree[T]
686+
def tag = Tag.RefinedTypeTree
594687
def forwardTo = tpt
595688
}
596689

597690
/** tpt[args] */
598691
case class AppliedTypeTree[-T >: Untyped] private[ast] (tpt: Tree[T], args: List[Tree[T]])
599692
extends ProxyTree[T] with TypTree[T] {
600693
type ThisTree[-T >: Untyped] = AppliedTypeTree[T]
694+
def tag = Tag.AppliedTypeTree
601695
def forwardTo = tpt
602696
}
603697

604698
/** [typeparams] -> tpt */
605699
case class LambdaTypeTree[-T >: Untyped] private[ast] (tparams: List[TypeDef[T]], body: Tree[T])
606700
extends TypTree[T] {
607701
type ThisTree[-T >: Untyped] = LambdaTypeTree[T]
702+
def tag = Tag.LambdaTypeTree
608703
}
609704

610705
/** => T */
611706
case class ByNameTypeTree[-T >: Untyped] private[ast] (result: Tree[T])
612707
extends TypTree[T] {
613708
type ThisTree[-T >: Untyped] = ByNameTypeTree[T]
709+
def tag = Tag.ByNameTypeTree
614710
}
615711

616712
/** >: lo <: hi */
617713
case class TypeBoundsTree[-T >: Untyped] private[ast] (lo: Tree[T], hi: Tree[T])
618714
extends TypTree[T] {
619715
type ThisTree[-T >: Untyped] = TypeBoundsTree[T]
716+
def tag = Tag.TypeBoundsTree
620717
}
621718

622719
/** name @ body */
623720
case class Bind[-T >: Untyped] private[ast] (name: Name, body: Tree[T])
624721
extends NameTree[T] with DefTree[T] with PatternTree[T] {
625722
type ThisTree[-T >: Untyped] = Bind[T]
723+
def tag = Tag.Bind
626724
override def isType = name.isTypeName
627725
override def isTerm = name.isTermName
628726
}
@@ -631,6 +729,7 @@ object Trees {
631729
case class Alternative[-T >: Untyped] private[ast] (trees: List[Tree[T]])
632730
extends PatternTree[T] {
633731
type ThisTree[-T >: Untyped] = Alternative[T]
732+
def tag = Tag.Alternative
634733
}
635734

636735
/** The typed translation of `extractor(patterns)` in a pattern. The translation has the following
@@ -650,12 +749,14 @@ object Trees {
650749
case class UnApply[-T >: Untyped] private[ast] (fun: Tree[T], implicits: List[Tree[T]], patterns: List[Tree[T]])
651750
extends PatternTree[T] {
652751
type ThisTree[-T >: Untyped] = UnApply[T]
752+
def tag = Tag.UnApply
653753
}
654754

655755
/** mods val name: tpt = rhs */
656756
case class ValDef[-T >: Untyped] private[ast] (name: TermName, tpt: Tree[T], private var preRhs: LazyTree)
657757
extends ValOrDefDef[T] {
658758
type ThisTree[-T >: Untyped] = ValDef[T]
759+
def tag = Tag.ValDef
659760
assert(isEmpty || tpt != genericEmptyTree)
660761
def unforced = preRhs
661762
protected def force(x: AnyRef) = preRhs = x
@@ -666,6 +767,7 @@ object Trees {
666767
vparamss: List[List[ValDef[T]]], tpt: Tree[T], private var preRhs: LazyTree)
667768
extends ValOrDefDef[T] {
668769
type ThisTree[-T >: Untyped] = DefDef[T]
770+
def tag = Tag.DefDef
669771
assert(tpt != genericEmptyTree)
670772
def unforced = preRhs
671773
protected def force(x: AnyRef) = preRhs = x
@@ -679,6 +781,7 @@ object Trees {
679781
case class TypeDef[-T >: Untyped] private[ast] (name: TypeName, rhs: Tree[T])
680782
extends MemberDef[T] {
681783
type ThisTree[-T >: Untyped] = TypeDef[T]
784+
def tag = Tag.TypeDef
682785

683786
/** Is this a definition of a class? */
684787
def isClassDef = rhs.isInstanceOf[Template[_]]
@@ -688,6 +791,7 @@ object Trees {
688791
case class Template[-T >: Untyped] private[ast] (constr: DefDef[T], parents: List[Tree[T]], self: ValDef[T], private var preBody: LazyTreeList)
689792
extends DefTree[T] with WithLazyField[List[Tree[T]]] {
690793
type ThisTree[-T >: Untyped] = Template[T]
794+
def tag = Tag.Template
691795
def unforcedBody = unforced
692796
def unforced = preBody
693797
protected def force(x: AnyRef) = preBody = x
@@ -701,19 +805,22 @@ object Trees {
701805
case class Import[-T >: Untyped] private[ast] (expr: Tree[T], selectors: List[Tree[Untyped]])
702806
extends DenotingTree[T] {
703807
type ThisTree[-T >: Untyped] = Import[T]
808+
def tag = Tag.Import
704809
}
705810

706811
/** package pid { stats } */
707812
case class PackageDef[-T >: Untyped] private[ast] (pid: RefTree[T], stats: List[Tree[T]])
708813
extends ProxyTree[T] {
709814
type ThisTree[-T >: Untyped] = PackageDef[T]
815+
def tag = Tag.PackageDef
710816
def forwardTo = pid
711817
}
712818

713819
/** arg @annot */
714820
case class Annotated[-T >: Untyped] private[ast] (arg: Tree[T], annot: Tree[T])
715821
extends ProxyTree[T] {
716822
type ThisTree[-T >: Untyped] = Annotated[T]
823+
def tag = Tag.Annotated
717824
def forwardTo = arg
718825
}
719826

@@ -732,6 +839,7 @@ object Trees {
732839
case class Thicket[-T >: Untyped](trees: List[Tree[T]])
733840
extends Tree[T] with WithoutTypeOrPos[T] {
734841
type ThisTree[-T >: Untyped] = Thicket[T]
842+
def tag = Tag.Thicket
735843
override def isEmpty: Boolean = trees.isEmpty
736844
override def toList: List[Tree[T]] = flatten(trees)
737845
override def toString = if (isEmpty) "EmptyTree" else "Thicket(" + trees.mkString(", ") + ")"

0 commit comments

Comments
 (0)