@@ -54,8 +54,9 @@ object Trees {
54
54
final val PackageDef = 29
55
55
final val Thicket = 30
56
56
57
+ /** The highest tree tag that can appear in a picked tree + 1 */
57
58
final val NumPickledTreeTags = 31
58
-
59
+
59
60
final val Annotated = 31
60
61
final val SingletonTypeTree = 32
61
62
final val AndTypeTree = 33
@@ -66,6 +67,7 @@ object Trees {
66
67
final val ByNameTypeTree = 38
67
68
final val TypeBoundsTree = 39
68
69
70
+ /** The highest tree tag that can appear in a typed tree + 1 */
69
71
final val NumTypedTreeTags = 40
70
72
71
73
final val TypedSplice = 40
@@ -89,6 +91,7 @@ object Trees {
89
91
final val ContextBounds = 48
90
92
final val PatDef = 49
91
93
94
+ /** The highest tree tag + 1 */
92
95
final val NumTags = 50
93
96
}
94
97
@@ -432,7 +435,7 @@ object Trees {
432
435
case class Ident [- T >: Untyped ] private [ast] (name : Name )
433
436
extends RefTree [T ] {
434
437
type ThisTree [- T >: Untyped ] = Ident [T ]
435
- def tag = Tag .Ident
438
+ final def tag = Tag .Ident
436
439
def qualifier : Tree [T ] = genericEmptyTree
437
440
438
441
/** Is this a `BackquotedIdent` ? */
@@ -450,7 +453,7 @@ object Trees {
450
453
case class Select [- T >: Untyped ] private [ast] (qualifier : Tree [T ], name : Name )
451
454
extends RefTree [T ] {
452
455
type ThisTree [- T >: Untyped ] = Select [T ]
453
- def tag = Tag .Select
456
+ final def tag = Tag .Select
454
457
}
455
458
456
459
class SelectWithSig [- T >: Untyped ] private [ast] (qualifier : Tree [T ], name : Name , val sig : Signature )
@@ -462,7 +465,7 @@ object Trees {
462
465
case class This [- T >: Untyped ] private [ast] (qual : untpd.Ident )
463
466
extends DenotingTree [T ] with TermTree [T ] {
464
467
type ThisTree [- T >: Untyped ] = This [T ]
465
- def tag = Tag .This
468
+ final def tag = Tag .This
466
469
// Denotation of a This tree is always the underlying class; needs correction for modules.
467
470
override def denot (implicit ctx : Context ): Denotation = {
468
471
typeOpt match {
@@ -478,7 +481,7 @@ object Trees {
478
481
case class Super [- T >: Untyped ] private [ast] (qual : Tree [T ], mix : untpd.Ident )
479
482
extends ProxyTree [T ] with TermTree [T ] {
480
483
type ThisTree [- T >: Untyped ] = Super [T ]
481
- def tag = Tag .Super
484
+ final def tag = Tag .Super
482
485
def forwardTo = qual
483
486
}
484
487
@@ -493,64 +496,64 @@ object Trees {
493
496
case class Apply [- T >: Untyped ] private [ast] (fun : Tree [T ], args : List [Tree [T ]])
494
497
extends GenericApply [T ] {
495
498
type ThisTree [- T >: Untyped ] = Apply [T ]
496
- def tag = Tag .Apply
499
+ final def tag = Tag .Apply
497
500
}
498
501
499
502
/** fun[args] */
500
503
case class TypeApply [- T >: Untyped ] private [ast] (fun : Tree [T ], args : List [Tree [T ]])
501
504
extends GenericApply [T ] {
502
505
type ThisTree [- T >: Untyped ] = TypeApply [T ]
503
- def tag = Tag .TypeApply
506
+ final def tag = Tag .TypeApply
504
507
}
505
508
506
509
/** const */
507
510
case class Literal [- T >: Untyped ] private [ast] (const : Constant )
508
511
extends TermTree [T ] {
509
512
type ThisTree [- T >: Untyped ] = Literal [T ]
510
- def tag = Tag .Literal
513
+ final def tag = Tag .Literal
511
514
}
512
515
513
516
/** new tpt, but no constructor call */
514
517
case class New [- T >: Untyped ] private [ast] (tpt : Tree [T ])
515
518
extends TermTree [T ] {
516
519
type ThisTree [- T >: Untyped ] = New [T ]
517
- def tag = Tag .New
520
+ final def tag = Tag .New
518
521
}
519
522
520
523
/** expr : tpt */
521
524
case class Typed [- T >: Untyped ] private [ast] (expr : Tree [T ], tpt : Tree [T ])
522
525
extends ProxyTree [T ] with TermTree [T ] {
523
526
type ThisTree [- T >: Untyped ] = Typed [T ]
524
- def tag = Tag .Typed
527
+ final def tag = Tag .Typed
525
528
def forwardTo = expr
526
529
}
527
530
528
531
/** name = arg, in a parameter list */
529
532
case class NamedArg [- T >: Untyped ] private [ast] (name : Name , arg : Tree [T ])
530
533
extends Tree [T ] {
531
534
type ThisTree [- T >: Untyped ] = NamedArg [T ]
532
- def tag = Tag .NamedArg
535
+ final def tag = Tag .NamedArg
533
536
}
534
537
535
538
/** name = arg, outside a parameter list */
536
539
case class Assign [- T >: Untyped ] private [ast] (lhs : Tree [T ], rhs : Tree [T ])
537
540
extends TermTree [T ] {
538
541
type ThisTree [- T >: Untyped ] = Assign [T ]
539
- def tag = Tag .Assign
542
+ final def tag = Tag .Assign
540
543
}
541
544
542
545
/** { stats; expr } */
543
546
case class Block [- T >: Untyped ] private [ast] (stats : List [Tree [T ]], expr : Tree [T ])
544
547
extends TermTree [T ] {
545
548
type ThisTree [- T >: Untyped ] = Block [T ]
546
- def tag = Tag .Block
549
+ final def tag = Tag .Block
547
550
}
548
551
549
552
/** if cond then thenp else elsep */
550
553
case class If [- T >: Untyped ] private [ast] (cond : Tree [T ], thenp : Tree [T ], elsep : Tree [T ])
551
554
extends TermTree [T ] {
552
555
type ThisTree [- T >: Untyped ] = If [T ]
553
- def tag = Tag .If
556
+ final def tag = Tag .If
554
557
}
555
558
556
559
/** A closure with an environment and a reference to a method.
@@ -565,21 +568,21 @@ object Trees {
565
568
case class Closure [- T >: Untyped ] private [ast] (env : List [Tree [T ]], meth : Tree [T ], tpt : Tree [T ])
566
569
extends TermTree [T ] {
567
570
type ThisTree [- T >: Untyped ] = Closure [T ]
568
- def tag = Tag .Closure
571
+ final def tag = Tag .Closure
569
572
}
570
573
571
574
/** selector match { cases } */
572
575
case class Match [- T >: Untyped ] private [ast] (selector : Tree [T ], cases : List [CaseDef [T ]])
573
576
extends TermTree [T ] {
574
577
type ThisTree [- T >: Untyped ] = Match [T ]
575
- def tag = Tag .Match
578
+ final def tag = Tag .Match
576
579
}
577
580
578
581
/** case pat if guard => body; only appears as child of a Match */
579
582
case class CaseDef [- T >: Untyped ] private [ast] (pat : Tree [T ], guard : Tree [T ], body : Tree [T ])
580
583
extends Tree [T ] {
581
584
type ThisTree [- T >: Untyped ] = CaseDef [T ]
582
- def tag = Tag .CaseDef
585
+ final def tag = Tag .CaseDef
583
586
}
584
587
585
588
/** return expr
@@ -590,7 +593,7 @@ object Trees {
590
593
case class Return [- T >: Untyped ] private [ast] (expr : Tree [T ], from : Tree [T ] = genericEmptyTree)
591
594
extends TermTree [T ] {
592
595
type ThisTree [- T >: Untyped ] = Return [T ]
593
- def tag = Tag .Return
596
+ final def tag = Tag .Return
594
597
}
595
598
596
599
/** try block catch handler finally finalizer
@@ -615,7 +618,7 @@ object Trees {
615
618
case class Try [- T >: Untyped ] private [ast] (expr : Tree [T ], cases : List [CaseDef [T ]], finalizer : Tree [T ])
616
619
extends TermTree [T ] {
617
620
type ThisTree [- T >: Untyped ] = Try [T ]
618
- def tag = Tag .Try
621
+ final def tag = Tag .Try
619
622
}
620
623
621
624
/** Seq(elems)
@@ -624,7 +627,7 @@ object Trees {
624
627
case class SeqLiteral [- T >: Untyped ] private [ast] (elems : List [Tree [T ]], elemtpt : Tree [T ])
625
628
extends Tree [T ] {
626
629
type ThisTree [- T >: Untyped ] = SeqLiteral [T ]
627
- def tag = Tag .SeqLiteral
630
+ final def tag = Tag .SeqLiteral
628
631
}
629
632
630
633
/** Array(elems) */
@@ -652,14 +655,14 @@ object Trees {
652
655
case class Inlined [- T >: Untyped ] private [ast] (call : tpd.Tree , bindings : List [MemberDef [T ]], expansion : Tree [T ])
653
656
extends Tree [T ] {
654
657
type ThisTree [- T >: Untyped ] = Inlined [T ]
655
- def tag = Tag .Inlined
658
+ final def tag = Tag .Inlined
656
659
}
657
660
658
661
/** A type tree that represents an existing or inferred type */
659
662
case class TypeTree [- T >: Untyped ] ()
660
663
extends DenotingTree [T ] with TypTree [T ] {
661
664
type ThisTree [- T >: Untyped ] = TypeTree [T ]
662
- def tag = Tag .TypeTree
665
+ final def tag = Tag .TypeTree
663
666
override def isEmpty = ! hasType
664
667
override def toString =
665
668
s " TypeTree ${if (hasType) s " [ $typeOpt] " else " " }"
@@ -669,65 +672,65 @@ object Trees {
669
672
case class SingletonTypeTree [- T >: Untyped ] private [ast] (ref : Tree [T ])
670
673
extends DenotingTree [T ] with TypTree [T ] {
671
674
type ThisTree [- T >: Untyped ] = SingletonTypeTree [T ]
672
- def tag = Tag .SingletonTypeTree
675
+ final def tag = Tag .SingletonTypeTree
673
676
}
674
677
675
678
/** left & right */
676
679
case class AndTypeTree [- T >: Untyped ] private [ast] (left : Tree [T ], right : Tree [T ])
677
680
extends TypTree [T ] {
678
681
type ThisTree [- T >: Untyped ] = AndTypeTree [T ]
679
- def tag = Tag .AndTypeTree
682
+ final def tag = Tag .AndTypeTree
680
683
}
681
684
682
685
/** left | right */
683
686
case class OrTypeTree [- T >: Untyped ] private [ast] (left : Tree [T ], right : Tree [T ])
684
687
extends TypTree [T ] {
685
688
type ThisTree [- T >: Untyped ] = OrTypeTree [T ]
686
- def tag = Tag .OrTypeTree
689
+ final def tag = Tag .OrTypeTree
687
690
}
688
691
689
692
/** tpt { refinements } */
690
693
case class RefinedTypeTree [- T >: Untyped ] private [ast] (tpt : Tree [T ], refinements : List [Tree [T ]])
691
694
extends ProxyTree [T ] with TypTree [T ] {
692
695
type ThisTree [- T >: Untyped ] = RefinedTypeTree [T ]
693
- def tag = Tag .RefinedTypeTree
696
+ final def tag = Tag .RefinedTypeTree
694
697
def forwardTo = tpt
695
698
}
696
699
697
700
/** tpt[args] */
698
701
case class AppliedTypeTree [- T >: Untyped ] private [ast] (tpt : Tree [T ], args : List [Tree [T ]])
699
702
extends ProxyTree [T ] with TypTree [T ] {
700
703
type ThisTree [- T >: Untyped ] = AppliedTypeTree [T ]
701
- def tag = Tag .AppliedTypeTree
704
+ final def tag = Tag .AppliedTypeTree
702
705
def forwardTo = tpt
703
706
}
704
707
705
708
/** [typeparams] -> tpt */
706
709
case class LambdaTypeTree [- T >: Untyped ] private [ast] (tparams : List [TypeDef [T ]], body : Tree [T ])
707
710
extends TypTree [T ] {
708
711
type ThisTree [- T >: Untyped ] = LambdaTypeTree [T ]
709
- def tag = Tag .LambdaTypeTree
712
+ final def tag = Tag .LambdaTypeTree
710
713
}
711
714
712
715
/** => T */
713
716
case class ByNameTypeTree [- T >: Untyped ] private [ast] (result : Tree [T ])
714
717
extends TypTree [T ] {
715
718
type ThisTree [- T >: Untyped ] = ByNameTypeTree [T ]
716
- def tag = Tag .ByNameTypeTree
719
+ final def tag = Tag .ByNameTypeTree
717
720
}
718
721
719
722
/** >: lo <: hi */
720
723
case class TypeBoundsTree [- T >: Untyped ] private [ast] (lo : Tree [T ], hi : Tree [T ])
721
724
extends TypTree [T ] {
722
725
type ThisTree [- T >: Untyped ] = TypeBoundsTree [T ]
723
- def tag = Tag .TypeBoundsTree
726
+ final def tag = Tag .TypeBoundsTree
724
727
}
725
728
726
729
/** name @ body */
727
730
case class Bind [- T >: Untyped ] private [ast] (name : Name , body : Tree [T ])
728
731
extends NameTree [T ] with DefTree [T ] with PatternTree [T ] {
729
732
type ThisTree [- T >: Untyped ] = Bind [T ]
730
- def tag = Tag .Bind
733
+ final def tag = Tag .Bind
731
734
override def isType = name.isTypeName
732
735
override def isTerm = name.isTermName
733
736
}
@@ -736,7 +739,7 @@ object Trees {
736
739
case class Alternative [- T >: Untyped ] private [ast] (trees : List [Tree [T ]])
737
740
extends PatternTree [T ] {
738
741
type ThisTree [- T >: Untyped ] = Alternative [T ]
739
- def tag = Tag .Alternative
742
+ final def tag = Tag .Alternative
740
743
}
741
744
742
745
/** The typed translation of `extractor(patterns)` in a pattern. The translation has the following
@@ -756,14 +759,14 @@ object Trees {
756
759
case class UnApply [- T >: Untyped ] private [ast] (fun : Tree [T ], implicits : List [Tree [T ]], patterns : List [Tree [T ]])
757
760
extends PatternTree [T ] {
758
761
type ThisTree [- T >: Untyped ] = UnApply [T ]
759
- def tag = Tag .UnApply
762
+ final def tag = Tag .UnApply
760
763
}
761
764
762
765
/** mods val name: tpt = rhs */
763
766
case class ValDef [- T >: Untyped ] private [ast] (name : TermName , tpt : Tree [T ], private var preRhs : LazyTree )
764
767
extends ValOrDefDef [T ] {
765
768
type ThisTree [- T >: Untyped ] = ValDef [T ]
766
- def tag = Tag .ValDef
769
+ final def tag = Tag .ValDef
767
770
assert(isEmpty || tpt != genericEmptyTree)
768
771
def unforced = preRhs
769
772
protected def force (x : AnyRef ) = preRhs = x
@@ -774,7 +777,7 @@ object Trees {
774
777
vparamss : List [List [ValDef [T ]]], tpt : Tree [T ], private var preRhs : LazyTree )
775
778
extends ValOrDefDef [T ] {
776
779
type ThisTree [- T >: Untyped ] = DefDef [T ]
777
- def tag = Tag .DefDef
780
+ final def tag = Tag .DefDef
778
781
assert(tpt != genericEmptyTree)
779
782
def unforced = preRhs
780
783
protected def force (x : AnyRef ) = preRhs = x
@@ -788,7 +791,7 @@ object Trees {
788
791
case class TypeDef [- T >: Untyped ] private [ast] (name : TypeName , rhs : Tree [T ])
789
792
extends MemberDef [T ] {
790
793
type ThisTree [- T >: Untyped ] = TypeDef [T ]
791
- def tag = Tag .TypeDef
794
+ final def tag = Tag .TypeDef
792
795
793
796
/** Is this a definition of a class? */
794
797
def isClassDef = rhs.isInstanceOf [Template [_]]
@@ -798,7 +801,7 @@ object Trees {
798
801
case class Template [- T >: Untyped ] private [ast] (constr : DefDef [T ], parents : List [Tree [T ]], self : ValDef [T ], private var preBody : LazyTreeList )
799
802
extends DefTree [T ] with WithLazyField [List [Tree [T ]]] {
800
803
type ThisTree [- T >: Untyped ] = Template [T ]
801
- def tag = Tag .Template
804
+ final def tag = Tag .Template
802
805
def unforcedBody = unforced
803
806
def unforced = preBody
804
807
protected def force (x : AnyRef ) = preBody = x
@@ -812,22 +815,22 @@ object Trees {
812
815
case class Import [- T >: Untyped ] private [ast] (expr : Tree [T ], selectors : List [Tree [Untyped ]])
813
816
extends DenotingTree [T ] {
814
817
type ThisTree [- T >: Untyped ] = Import [T ]
815
- def tag = Tag .Import
818
+ final def tag = Tag .Import
816
819
}
817
820
818
821
/** package pid { stats } */
819
822
case class PackageDef [- T >: Untyped ] private [ast] (pid : RefTree [T ], stats : List [Tree [T ]])
820
823
extends ProxyTree [T ] {
821
824
type ThisTree [- T >: Untyped ] = PackageDef [T ]
822
- def tag = Tag .PackageDef
825
+ final def tag = Tag .PackageDef
823
826
def forwardTo = pid
824
827
}
825
828
826
829
/** arg @annot */
827
830
case class Annotated [- T >: Untyped ] private [ast] (arg : Tree [T ], annot : Tree [T ])
828
831
extends ProxyTree [T ] {
829
832
type ThisTree [- T >: Untyped ] = Annotated [T ]
830
- def tag = Tag .Annotated
833
+ final def tag = Tag .Annotated
831
834
def forwardTo = arg
832
835
}
833
836
@@ -846,7 +849,7 @@ object Trees {
846
849
case class Thicket [- T >: Untyped ](trees : List [Tree [T ]])
847
850
extends Tree [T ] with WithoutTypeOrPos [T ] {
848
851
type ThisTree [- T >: Untyped ] = Thicket [T ]
849
- def tag = Tag .Thicket
852
+ final def tag = Tag .Thicket
850
853
override def isEmpty : Boolean = trees.isEmpty
851
854
override def toList : List [Tree [T ]] = flatten(trees)
852
855
override def toString = if (isEmpty) " EmptyTree" else " Thicket(" + trees.mkString(" , " ) + " )"
0 commit comments