@@ -19,6 +19,72 @@ import language.implicitConversions
19
19
20
20
object Trees {
21
21
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
+
22
88
// Note: it would be more logical to make Untyped = Nothing.
23
89
// However, this interacts in a bad way with Scala's current type inference.
24
90
// In fact, we cannot write something like Select(pre, name), where pre is
@@ -78,6 +144,8 @@ object Trees {
78
144
/** The type constructor at the root of the tree */
79
145
type ThisTree [T >: Untyped ] <: Tree [T ]
80
146
147
+ def tag : TreeTag
148
+
81
149
private [this ] var myTpe : T = _
82
150
83
151
/** Destructively set the type of the tree. This should be called only when it is known that
@@ -357,6 +425,7 @@ object Trees {
357
425
case class Ident [- T >: Untyped ] private [ast] (name : Name )
358
426
extends RefTree [T ] {
359
427
type ThisTree [- T >: Untyped ] = Ident [T ]
428
+ def tag = Tag .Ident
360
429
def qualifier : Tree [T ] = genericEmptyTree
361
430
362
431
/** Is this a `BackquotedIdent` ? */
@@ -374,6 +443,7 @@ object Trees {
374
443
case class Select [- T >: Untyped ] private [ast] (qualifier : Tree [T ], name : Name )
375
444
extends RefTree [T ] {
376
445
type ThisTree [- T >: Untyped ] = Select [T ]
446
+ def tag = Tag .Select
377
447
}
378
448
379
449
class SelectWithSig [- T >: Untyped ] private [ast] (qualifier : Tree [T ], name : Name , val sig : Signature )
@@ -385,6 +455,7 @@ object Trees {
385
455
case class This [- T >: Untyped ] private [ast] (qual : untpd.Ident )
386
456
extends DenotingTree [T ] with TermTree [T ] {
387
457
type ThisTree [- T >: Untyped ] = This [T ]
458
+ def tag = Tag .This
388
459
// Denotation of a This tree is always the underlying class; needs correction for modules.
389
460
override def denot (implicit ctx : Context ): Denotation = {
390
461
typeOpt match {
@@ -400,6 +471,7 @@ object Trees {
400
471
case class Super [- T >: Untyped ] private [ast] (qual : Tree [T ], mix : untpd.Ident )
401
472
extends ProxyTree [T ] with TermTree [T ] {
402
473
type ThisTree [- T >: Untyped ] = Super [T ]
474
+ def tag = Tag .Super
403
475
def forwardTo = qual
404
476
}
405
477
@@ -414,55 +486,64 @@ object Trees {
414
486
case class Apply [- T >: Untyped ] private [ast] (fun : Tree [T ], args : List [Tree [T ]])
415
487
extends GenericApply [T ] {
416
488
type ThisTree [- T >: Untyped ] = Apply [T ]
489
+ def tag = Tag .Apply
417
490
}
418
491
419
492
/** fun[args] */
420
493
case class TypeApply [- T >: Untyped ] private [ast] (fun : Tree [T ], args : List [Tree [T ]])
421
494
extends GenericApply [T ] {
422
495
type ThisTree [- T >: Untyped ] = TypeApply [T ]
496
+ def tag = Tag .TypeApply
423
497
}
424
498
425
499
/** const */
426
500
case class Literal [- T >: Untyped ] private [ast] (const : Constant )
427
501
extends TermTree [T ] {
428
502
type ThisTree [- T >: Untyped ] = Literal [T ]
503
+ def tag = Tag .Literal
429
504
}
430
505
431
506
/** new tpt, but no constructor call */
432
507
case class New [- T >: Untyped ] private [ast] (tpt : Tree [T ])
433
508
extends TermTree [T ] {
434
509
type ThisTree [- T >: Untyped ] = New [T ]
510
+ def tag = Tag .New
435
511
}
436
512
437
513
/** expr : tpt */
438
514
case class Typed [- T >: Untyped ] private [ast] (expr : Tree [T ], tpt : Tree [T ])
439
515
extends ProxyTree [T ] with TermTree [T ] {
440
516
type ThisTree [- T >: Untyped ] = Typed [T ]
517
+ def tag = Tag .Typed
441
518
def forwardTo = expr
442
519
}
443
520
444
521
/** name = arg, in a parameter list */
445
522
case class NamedArg [- T >: Untyped ] private [ast] (name : Name , arg : Tree [T ])
446
523
extends Tree [T ] {
447
524
type ThisTree [- T >: Untyped ] = NamedArg [T ]
525
+ def tag = Tag .NamedArg
448
526
}
449
527
450
528
/** name = arg, outside a parameter list */
451
529
case class Assign [- T >: Untyped ] private [ast] (lhs : Tree [T ], rhs : Tree [T ])
452
530
extends TermTree [T ] {
453
531
type ThisTree [- T >: Untyped ] = Assign [T ]
532
+ def tag = Tag .Assign
454
533
}
455
534
456
535
/** { stats; expr } */
457
536
case class Block [- T >: Untyped ] private [ast] (stats : List [Tree [T ]], expr : Tree [T ])
458
537
extends TermTree [T ] {
459
538
type ThisTree [- T >: Untyped ] = Block [T ]
539
+ def tag = Tag .Block
460
540
}
461
541
462
542
/** if cond then thenp else elsep */
463
543
case class If [- T >: Untyped ] private [ast] (cond : Tree [T ], thenp : Tree [T ], elsep : Tree [T ])
464
544
extends TermTree [T ] {
465
545
type ThisTree [- T >: Untyped ] = If [T ]
546
+ def tag = Tag .If
466
547
}
467
548
468
549
/** A closure with an environment and a reference to a method.
@@ -477,18 +558,21 @@ object Trees {
477
558
case class Closure [- T >: Untyped ] private [ast] (env : List [Tree [T ]], meth : Tree [T ], tpt : Tree [T ])
478
559
extends TermTree [T ] {
479
560
type ThisTree [- T >: Untyped ] = Closure [T ]
561
+ def tag = Tag .Closure
480
562
}
481
563
482
564
/** selector match { cases } */
483
565
case class Match [- T >: Untyped ] private [ast] (selector : Tree [T ], cases : List [CaseDef [T ]])
484
566
extends TermTree [T ] {
485
567
type ThisTree [- T >: Untyped ] = Match [T ]
568
+ def tag = Tag .Match
486
569
}
487
570
488
571
/** case pat if guard => body; only appears as child of a Match */
489
572
case class CaseDef [- T >: Untyped ] private [ast] (pat : Tree [T ], guard : Tree [T ], body : Tree [T ])
490
573
extends Tree [T ] {
491
574
type ThisTree [- T >: Untyped ] = CaseDef [T ]
575
+ def tag = Tag .CaseDef
492
576
}
493
577
494
578
/** return expr
@@ -499,6 +583,7 @@ object Trees {
499
583
case class Return [- T >: Untyped ] private [ast] (expr : Tree [T ], from : Tree [T ] = genericEmptyTree)
500
584
extends TermTree [T ] {
501
585
type ThisTree [- T >: Untyped ] = Return [T ]
586
+ def tag = Tag .Return
502
587
}
503
588
504
589
/** try block catch handler finally finalizer
@@ -523,6 +608,7 @@ object Trees {
523
608
case class Try [- T >: Untyped ] private [ast] (expr : Tree [T ], cases : List [CaseDef [T ]], finalizer : Tree [T ])
524
609
extends TermTree [T ] {
525
610
type ThisTree [- T >: Untyped ] = Try [T ]
611
+ def tag = Tag .Try
526
612
}
527
613
528
614
/** Seq(elems)
@@ -531,6 +617,7 @@ object Trees {
531
617
case class SeqLiteral [- T >: Untyped ] private [ast] (elems : List [Tree [T ]], elemtpt : Tree [T ])
532
618
extends Tree [T ] {
533
619
type ThisTree [- T >: Untyped ] = SeqLiteral [T ]
620
+ def tag = Tag .SeqLiteral
534
621
}
535
622
536
623
/** Array(elems) */
@@ -558,12 +645,14 @@ object Trees {
558
645
case class Inlined [- T >: Untyped ] private [ast] (call : tpd.Tree , bindings : List [MemberDef [T ]], expansion : Tree [T ])
559
646
extends Tree [T ] {
560
647
type ThisTree [- T >: Untyped ] = Inlined [T ]
648
+ def tag = Tag .Inlined
561
649
}
562
650
563
651
/** A type tree that represents an existing or inferred type */
564
652
case class TypeTree [- T >: Untyped ] ()
565
653
extends DenotingTree [T ] with TypTree [T ] {
566
654
type ThisTree [- T >: Untyped ] = TypeTree [T ]
655
+ def tag = Tag .TypeTree
567
656
override def isEmpty = ! hasType
568
657
override def toString =
569
658
s " TypeTree ${if (hasType) s " [ $typeOpt] " else " " }"
@@ -573,56 +662,65 @@ object Trees {
573
662
case class SingletonTypeTree [- T >: Untyped ] private [ast] (ref : Tree [T ])
574
663
extends DenotingTree [T ] with TypTree [T ] {
575
664
type ThisTree [- T >: Untyped ] = SingletonTypeTree [T ]
665
+ def tag = Tag .SingletonTypeTree
576
666
}
577
667
578
668
/** left & right */
579
669
case class AndTypeTree [- T >: Untyped ] private [ast] (left : Tree [T ], right : Tree [T ])
580
670
extends TypTree [T ] {
581
671
type ThisTree [- T >: Untyped ] = AndTypeTree [T ]
672
+ def tag = Tag .AndTypeTree
582
673
}
583
674
584
675
/** left | right */
585
676
case class OrTypeTree [- T >: Untyped ] private [ast] (left : Tree [T ], right : Tree [T ])
586
677
extends TypTree [T ] {
587
678
type ThisTree [- T >: Untyped ] = OrTypeTree [T ]
679
+ def tag = Tag .OrTypeTree
588
680
}
589
681
590
682
/** tpt { refinements } */
591
683
case class RefinedTypeTree [- T >: Untyped ] private [ast] (tpt : Tree [T ], refinements : List [Tree [T ]])
592
684
extends ProxyTree [T ] with TypTree [T ] {
593
685
type ThisTree [- T >: Untyped ] = RefinedTypeTree [T ]
686
+ def tag = Tag .RefinedTypeTree
594
687
def forwardTo = tpt
595
688
}
596
689
597
690
/** tpt[args] */
598
691
case class AppliedTypeTree [- T >: Untyped ] private [ast] (tpt : Tree [T ], args : List [Tree [T ]])
599
692
extends ProxyTree [T ] with TypTree [T ] {
600
693
type ThisTree [- T >: Untyped ] = AppliedTypeTree [T ]
694
+ def tag = Tag .AppliedTypeTree
601
695
def forwardTo = tpt
602
696
}
603
697
604
698
/** [typeparams] -> tpt */
605
699
case class LambdaTypeTree [- T >: Untyped ] private [ast] (tparams : List [TypeDef [T ]], body : Tree [T ])
606
700
extends TypTree [T ] {
607
701
type ThisTree [- T >: Untyped ] = LambdaTypeTree [T ]
702
+ def tag = Tag .LambdaTypeTree
608
703
}
609
704
610
705
/** => T */
611
706
case class ByNameTypeTree [- T >: Untyped ] private [ast] (result : Tree [T ])
612
707
extends TypTree [T ] {
613
708
type ThisTree [- T >: Untyped ] = ByNameTypeTree [T ]
709
+ def tag = Tag .ByNameTypeTree
614
710
}
615
711
616
712
/** >: lo <: hi */
617
713
case class TypeBoundsTree [- T >: Untyped ] private [ast] (lo : Tree [T ], hi : Tree [T ])
618
714
extends TypTree [T ] {
619
715
type ThisTree [- T >: Untyped ] = TypeBoundsTree [T ]
716
+ def tag = Tag .TypeBoundsTree
620
717
}
621
718
622
719
/** name @ body */
623
720
case class Bind [- T >: Untyped ] private [ast] (name : Name , body : Tree [T ])
624
721
extends NameTree [T ] with DefTree [T ] with PatternTree [T ] {
625
722
type ThisTree [- T >: Untyped ] = Bind [T ]
723
+ def tag = Tag .Bind
626
724
override def isType = name.isTypeName
627
725
override def isTerm = name.isTermName
628
726
}
@@ -631,6 +729,7 @@ object Trees {
631
729
case class Alternative [- T >: Untyped ] private [ast] (trees : List [Tree [T ]])
632
730
extends PatternTree [T ] {
633
731
type ThisTree [- T >: Untyped ] = Alternative [T ]
732
+ def tag = Tag .Alternative
634
733
}
635
734
636
735
/** The typed translation of `extractor(patterns)` in a pattern. The translation has the following
@@ -650,12 +749,14 @@ object Trees {
650
749
case class UnApply [- T >: Untyped ] private [ast] (fun : Tree [T ], implicits : List [Tree [T ]], patterns : List [Tree [T ]])
651
750
extends PatternTree [T ] {
652
751
type ThisTree [- T >: Untyped ] = UnApply [T ]
752
+ def tag = Tag .UnApply
653
753
}
654
754
655
755
/** mods val name: tpt = rhs */
656
756
case class ValDef [- T >: Untyped ] private [ast] (name : TermName , tpt : Tree [T ], private var preRhs : LazyTree )
657
757
extends ValOrDefDef [T ] {
658
758
type ThisTree [- T >: Untyped ] = ValDef [T ]
759
+ def tag = Tag .ValDef
659
760
assert(isEmpty || tpt != genericEmptyTree)
660
761
def unforced = preRhs
661
762
protected def force (x : AnyRef ) = preRhs = x
@@ -666,6 +767,7 @@ object Trees {
666
767
vparamss : List [List [ValDef [T ]]], tpt : Tree [T ], private var preRhs : LazyTree )
667
768
extends ValOrDefDef [T ] {
668
769
type ThisTree [- T >: Untyped ] = DefDef [T ]
770
+ def tag = Tag .DefDef
669
771
assert(tpt != genericEmptyTree)
670
772
def unforced = preRhs
671
773
protected def force (x : AnyRef ) = preRhs = x
@@ -679,6 +781,7 @@ object Trees {
679
781
case class TypeDef [- T >: Untyped ] private [ast] (name : TypeName , rhs : Tree [T ])
680
782
extends MemberDef [T ] {
681
783
type ThisTree [- T >: Untyped ] = TypeDef [T ]
784
+ def tag = Tag .TypeDef
682
785
683
786
/** Is this a definition of a class? */
684
787
def isClassDef = rhs.isInstanceOf [Template [_]]
@@ -688,6 +791,7 @@ object Trees {
688
791
case class Template [- T >: Untyped ] private [ast] (constr : DefDef [T ], parents : List [Tree [T ]], self : ValDef [T ], private var preBody : LazyTreeList )
689
792
extends DefTree [T ] with WithLazyField [List [Tree [T ]]] {
690
793
type ThisTree [- T >: Untyped ] = Template [T ]
794
+ def tag = Tag .Template
691
795
def unforcedBody = unforced
692
796
def unforced = preBody
693
797
protected def force (x : AnyRef ) = preBody = x
@@ -701,19 +805,22 @@ object Trees {
701
805
case class Import [- T >: Untyped ] private [ast] (expr : Tree [T ], selectors : List [Tree [Untyped ]])
702
806
extends DenotingTree [T ] {
703
807
type ThisTree [- T >: Untyped ] = Import [T ]
808
+ def tag = Tag .Import
704
809
}
705
810
706
811
/** package pid { stats } */
707
812
case class PackageDef [- T >: Untyped ] private [ast] (pid : RefTree [T ], stats : List [Tree [T ]])
708
813
extends ProxyTree [T ] {
709
814
type ThisTree [- T >: Untyped ] = PackageDef [T ]
815
+ def tag = Tag .PackageDef
710
816
def forwardTo = pid
711
817
}
712
818
713
819
/** arg @annot */
714
820
case class Annotated [- T >: Untyped ] private [ast] (arg : Tree [T ], annot : Tree [T ])
715
821
extends ProxyTree [T ] {
716
822
type ThisTree [- T >: Untyped ] = Annotated [T ]
823
+ def tag = Tag .Annotated
717
824
def forwardTo = arg
718
825
}
719
826
@@ -732,6 +839,7 @@ object Trees {
732
839
case class Thicket [- T >: Untyped ](trees : List [Tree [T ]])
733
840
extends Tree [T ] with WithoutTypeOrPos [T ] {
734
841
type ThisTree [- T >: Untyped ] = Thicket [T ]
842
+ def tag = Tag .Thicket
735
843
override def isEmpty : Boolean = trees.isEmpty
736
844
override def toList : List [Tree [T ]] = flatten(trees)
737
845
override def toString = if (isEmpty) " EmptyTree" else " Thicket(" + trees.mkString(" , " ) + " )"
0 commit comments