Skip to content

Commit 346f1f2

Browse files
committed
Bring back relaxedTyping
1 parent 0bd23f8 commit 346f1f2

File tree

6 files changed

+92
-65
lines changed

6 files changed

+92
-65
lines changed

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

Lines changed: 44 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -54,8 +54,9 @@ object Trees {
5454
final val PackageDef = 29
5555
final val Thicket = 30
5656

57+
/** The highest tree tag that can appear in a picked tree + 1 */
5758
final val NumPickledTreeTags = 31
58-
59+
5960
final val Annotated = 31
6061
final val SingletonTypeTree = 32
6162
final val AndTypeTree = 33
@@ -66,6 +67,7 @@ object Trees {
6667
final val ByNameTypeTree = 38
6768
final val TypeBoundsTree = 39
6869

70+
/** The highest tree tag that can appear in a typed tree + 1 */
6971
final val NumTypedTreeTags = 40
7072

7173
final val TypedSplice = 40
@@ -89,6 +91,7 @@ object Trees {
8991
final val ContextBounds = 48
9092
final val PatDef = 49
9193

94+
/** The highest tree tag + 1 */
9295
final val NumTags = 50
9396
}
9497

@@ -432,7 +435,7 @@ object Trees {
432435
case class Ident[-T >: Untyped] private[ast] (name: Name)
433436
extends RefTree[T] {
434437
type ThisTree[-T >: Untyped] = Ident[T]
435-
def tag = Tag.Ident
438+
final def tag = Tag.Ident
436439
def qualifier: Tree[T] = genericEmptyTree
437440

438441
/** Is this a `BackquotedIdent` ? */
@@ -450,7 +453,7 @@ object Trees {
450453
case class Select[-T >: Untyped] private[ast] (qualifier: Tree[T], name: Name)
451454
extends RefTree[T] {
452455
type ThisTree[-T >: Untyped] = Select[T]
453-
def tag = Tag.Select
456+
final def tag = Tag.Select
454457
}
455458

456459
class SelectWithSig[-T >: Untyped] private[ast] (qualifier: Tree[T], name: Name, val sig: Signature)
@@ -462,7 +465,7 @@ object Trees {
462465
case class This[-T >: Untyped] private[ast] (qual: untpd.Ident)
463466
extends DenotingTree[T] with TermTree[T] {
464467
type ThisTree[-T >: Untyped] = This[T]
465-
def tag = Tag.This
468+
final def tag = Tag.This
466469
// Denotation of a This tree is always the underlying class; needs correction for modules.
467470
override def denot(implicit ctx: Context): Denotation = {
468471
typeOpt match {
@@ -478,7 +481,7 @@ object Trees {
478481
case class Super[-T >: Untyped] private[ast] (qual: Tree[T], mix: untpd.Ident)
479482
extends ProxyTree[T] with TermTree[T] {
480483
type ThisTree[-T >: Untyped] = Super[T]
481-
def tag = Tag.Super
484+
final def tag = Tag.Super
482485
def forwardTo = qual
483486
}
484487

@@ -493,64 +496,64 @@ object Trees {
493496
case class Apply[-T >: Untyped] private[ast] (fun: Tree[T], args: List[Tree[T]])
494497
extends GenericApply[T] {
495498
type ThisTree[-T >: Untyped] = Apply[T]
496-
def tag = Tag.Apply
499+
final def tag = Tag.Apply
497500
}
498501

499502
/** fun[args] */
500503
case class TypeApply[-T >: Untyped] private[ast] (fun: Tree[T], args: List[Tree[T]])
501504
extends GenericApply[T] {
502505
type ThisTree[-T >: Untyped] = TypeApply[T]
503-
def tag = Tag.TypeApply
506+
final def tag = Tag.TypeApply
504507
}
505508

506509
/** const */
507510
case class Literal[-T >: Untyped] private[ast] (const: Constant)
508511
extends TermTree[T] {
509512
type ThisTree[-T >: Untyped] = Literal[T]
510-
def tag = Tag.Literal
513+
final def tag = Tag.Literal
511514
}
512515

513516
/** new tpt, but no constructor call */
514517
case class New[-T >: Untyped] private[ast] (tpt: Tree[T])
515518
extends TermTree[T] {
516519
type ThisTree[-T >: Untyped] = New[T]
517-
def tag = Tag.New
520+
final def tag = Tag.New
518521
}
519522

520523
/** expr : tpt */
521524
case class Typed[-T >: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])
522525
extends ProxyTree[T] with TermTree[T] {
523526
type ThisTree[-T >: Untyped] = Typed[T]
524-
def tag = Tag.Typed
527+
final def tag = Tag.Typed
525528
def forwardTo = expr
526529
}
527530

528531
/** name = arg, in a parameter list */
529532
case class NamedArg[-T >: Untyped] private[ast] (name: Name, arg: Tree[T])
530533
extends Tree[T] {
531534
type ThisTree[-T >: Untyped] = NamedArg[T]
532-
def tag = Tag.NamedArg
535+
final def tag = Tag.NamedArg
533536
}
534537

535538
/** name = arg, outside a parameter list */
536539
case class Assign[-T >: Untyped] private[ast] (lhs: Tree[T], rhs: Tree[T])
537540
extends TermTree[T] {
538541
type ThisTree[-T >: Untyped] = Assign[T]
539-
def tag = Tag.Assign
542+
final def tag = Tag.Assign
540543
}
541544

542545
/** { stats; expr } */
543546
case class Block[-T >: Untyped] private[ast] (stats: List[Tree[T]], expr: Tree[T])
544547
extends TermTree[T] {
545548
type ThisTree[-T >: Untyped] = Block[T]
546-
def tag = Tag.Block
549+
final def tag = Tag.Block
547550
}
548551

549552
/** if cond then thenp else elsep */
550553
case class If[-T >: Untyped] private[ast] (cond: Tree[T], thenp: Tree[T], elsep: Tree[T])
551554
extends TermTree[T] {
552555
type ThisTree[-T >: Untyped] = If[T]
553-
def tag = Tag.If
556+
final def tag = Tag.If
554557
}
555558

556559
/** A closure with an environment and a reference to a method.
@@ -565,21 +568,21 @@ object Trees {
565568
case class Closure[-T >: Untyped] private[ast] (env: List[Tree[T]], meth: Tree[T], tpt: Tree[T])
566569
extends TermTree[T] {
567570
type ThisTree[-T >: Untyped] = Closure[T]
568-
def tag = Tag.Closure
571+
final def tag = Tag.Closure
569572
}
570573

571574
/** selector match { cases } */
572575
case class Match[-T >: Untyped] private[ast] (selector: Tree[T], cases: List[CaseDef[T]])
573576
extends TermTree[T] {
574577
type ThisTree[-T >: Untyped] = Match[T]
575-
def tag = Tag.Match
578+
final def tag = Tag.Match
576579
}
577580

578581
/** case pat if guard => body; only appears as child of a Match */
579582
case class CaseDef[-T >: Untyped] private[ast] (pat: Tree[T], guard: Tree[T], body: Tree[T])
580583
extends Tree[T] {
581584
type ThisTree[-T >: Untyped] = CaseDef[T]
582-
def tag = Tag.CaseDef
585+
final def tag = Tag.CaseDef
583586
}
584587

585588
/** return expr
@@ -590,7 +593,7 @@ object Trees {
590593
case class Return[-T >: Untyped] private[ast] (expr: Tree[T], from: Tree[T] = genericEmptyTree)
591594
extends TermTree[T] {
592595
type ThisTree[-T >: Untyped] = Return[T]
593-
def tag = Tag.Return
596+
final def tag = Tag.Return
594597
}
595598

596599
/** try block catch handler finally finalizer
@@ -615,7 +618,7 @@ object Trees {
615618
case class Try[-T >: Untyped] private[ast] (expr: Tree[T], cases: List[CaseDef[T]], finalizer: Tree[T])
616619
extends TermTree[T] {
617620
type ThisTree[-T >: Untyped] = Try[T]
618-
def tag = Tag.Try
621+
final def tag = Tag.Try
619622
}
620623

621624
/** Seq(elems)
@@ -624,7 +627,7 @@ object Trees {
624627
case class SeqLiteral[-T >: Untyped] private[ast] (elems: List[Tree[T]], elemtpt: Tree[T])
625628
extends Tree[T] {
626629
type ThisTree[-T >: Untyped] = SeqLiteral[T]
627-
def tag = Tag.SeqLiteral
630+
final def tag = Tag.SeqLiteral
628631
}
629632

630633
/** Array(elems) */
@@ -652,14 +655,14 @@ object Trees {
652655
case class Inlined[-T >: Untyped] private[ast] (call: tpd.Tree, bindings: List[MemberDef[T]], expansion: Tree[T])
653656
extends Tree[T] {
654657
type ThisTree[-T >: Untyped] = Inlined[T]
655-
def tag = Tag.Inlined
658+
final def tag = Tag.Inlined
656659
}
657660

658661
/** A type tree that represents an existing or inferred type */
659662
case class TypeTree[-T >: Untyped] ()
660663
extends DenotingTree[T] with TypTree[T] {
661664
type ThisTree[-T >: Untyped] = TypeTree[T]
662-
def tag = Tag.TypeTree
665+
final def tag = Tag.TypeTree
663666
override def isEmpty = !hasType
664667
override def toString =
665668
s"TypeTree${if (hasType) s"[$typeOpt]" else ""}"
@@ -669,65 +672,65 @@ object Trees {
669672
case class SingletonTypeTree[-T >: Untyped] private[ast] (ref: Tree[T])
670673
extends DenotingTree[T] with TypTree[T] {
671674
type ThisTree[-T >: Untyped] = SingletonTypeTree[T]
672-
def tag = Tag.SingletonTypeTree
675+
final def tag = Tag.SingletonTypeTree
673676
}
674677

675678
/** left & right */
676679
case class AndTypeTree[-T >: Untyped] private[ast] (left: Tree[T], right: Tree[T])
677680
extends TypTree[T] {
678681
type ThisTree[-T >: Untyped] = AndTypeTree[T]
679-
def tag = Tag.AndTypeTree
682+
final def tag = Tag.AndTypeTree
680683
}
681684

682685
/** left | right */
683686
case class OrTypeTree[-T >: Untyped] private[ast] (left: Tree[T], right: Tree[T])
684687
extends TypTree[T] {
685688
type ThisTree[-T >: Untyped] = OrTypeTree[T]
686-
def tag = Tag.OrTypeTree
689+
final def tag = Tag.OrTypeTree
687690
}
688691

689692
/** tpt { refinements } */
690693
case class RefinedTypeTree[-T >: Untyped] private[ast] (tpt: Tree[T], refinements: List[Tree[T]])
691694
extends ProxyTree[T] with TypTree[T] {
692695
type ThisTree[-T >: Untyped] = RefinedTypeTree[T]
693-
def tag = Tag.RefinedTypeTree
696+
final def tag = Tag.RefinedTypeTree
694697
def forwardTo = tpt
695698
}
696699

697700
/** tpt[args] */
698701
case class AppliedTypeTree[-T >: Untyped] private[ast] (tpt: Tree[T], args: List[Tree[T]])
699702
extends ProxyTree[T] with TypTree[T] {
700703
type ThisTree[-T >: Untyped] = AppliedTypeTree[T]
701-
def tag = Tag.AppliedTypeTree
704+
final def tag = Tag.AppliedTypeTree
702705
def forwardTo = tpt
703706
}
704707

705708
/** [typeparams] -> tpt */
706709
case class LambdaTypeTree[-T >: Untyped] private[ast] (tparams: List[TypeDef[T]], body: Tree[T])
707710
extends TypTree[T] {
708711
type ThisTree[-T >: Untyped] = LambdaTypeTree[T]
709-
def tag = Tag.LambdaTypeTree
712+
final def tag = Tag.LambdaTypeTree
710713
}
711714

712715
/** => T */
713716
case class ByNameTypeTree[-T >: Untyped] private[ast] (result: Tree[T])
714717
extends TypTree[T] {
715718
type ThisTree[-T >: Untyped] = ByNameTypeTree[T]
716-
def tag = Tag.ByNameTypeTree
719+
final def tag = Tag.ByNameTypeTree
717720
}
718721

719722
/** >: lo <: hi */
720723
case class TypeBoundsTree[-T >: Untyped] private[ast] (lo: Tree[T], hi: Tree[T])
721724
extends TypTree[T] {
722725
type ThisTree[-T >: Untyped] = TypeBoundsTree[T]
723-
def tag = Tag.TypeBoundsTree
726+
final def tag = Tag.TypeBoundsTree
724727
}
725728

726729
/** name @ body */
727730
case class Bind[-T >: Untyped] private[ast] (name: Name, body: Tree[T])
728731
extends NameTree[T] with DefTree[T] with PatternTree[T] {
729732
type ThisTree[-T >: Untyped] = Bind[T]
730-
def tag = Tag.Bind
733+
final def tag = Tag.Bind
731734
override def isType = name.isTypeName
732735
override def isTerm = name.isTermName
733736
}
@@ -736,7 +739,7 @@ object Trees {
736739
case class Alternative[-T >: Untyped] private[ast] (trees: List[Tree[T]])
737740
extends PatternTree[T] {
738741
type ThisTree[-T >: Untyped] = Alternative[T]
739-
def tag = Tag.Alternative
742+
final def tag = Tag.Alternative
740743
}
741744

742745
/** The typed translation of `extractor(patterns)` in a pattern. The translation has the following
@@ -756,14 +759,14 @@ object Trees {
756759
case class UnApply[-T >: Untyped] private[ast] (fun: Tree[T], implicits: List[Tree[T]], patterns: List[Tree[T]])
757760
extends PatternTree[T] {
758761
type ThisTree[-T >: Untyped] = UnApply[T]
759-
def tag = Tag.UnApply
762+
final def tag = Tag.UnApply
760763
}
761764

762765
/** mods val name: tpt = rhs */
763766
case class ValDef[-T >: Untyped] private[ast] (name: TermName, tpt: Tree[T], private var preRhs: LazyTree)
764767
extends ValOrDefDef[T] {
765768
type ThisTree[-T >: Untyped] = ValDef[T]
766-
def tag = Tag.ValDef
769+
final def tag = Tag.ValDef
767770
assert(isEmpty || tpt != genericEmptyTree)
768771
def unforced = preRhs
769772
protected def force(x: AnyRef) = preRhs = x
@@ -774,7 +777,7 @@ object Trees {
774777
vparamss: List[List[ValDef[T]]], tpt: Tree[T], private var preRhs: LazyTree)
775778
extends ValOrDefDef[T] {
776779
type ThisTree[-T >: Untyped] = DefDef[T]
777-
def tag = Tag.DefDef
780+
final def tag = Tag.DefDef
778781
assert(tpt != genericEmptyTree)
779782
def unforced = preRhs
780783
protected def force(x: AnyRef) = preRhs = x
@@ -788,7 +791,7 @@ object Trees {
788791
case class TypeDef[-T >: Untyped] private[ast] (name: TypeName, rhs: Tree[T])
789792
extends MemberDef[T] {
790793
type ThisTree[-T >: Untyped] = TypeDef[T]
791-
def tag = Tag.TypeDef
794+
final def tag = Tag.TypeDef
792795

793796
/** Is this a definition of a class? */
794797
def isClassDef = rhs.isInstanceOf[Template[_]]
@@ -798,7 +801,7 @@ object Trees {
798801
case class Template[-T >: Untyped] private[ast] (constr: DefDef[T], parents: List[Tree[T]], self: ValDef[T], private var preBody: LazyTreeList)
799802
extends DefTree[T] with WithLazyField[List[Tree[T]]] {
800803
type ThisTree[-T >: Untyped] = Template[T]
801-
def tag = Tag.Template
804+
final def tag = Tag.Template
802805
def unforcedBody = unforced
803806
def unforced = preBody
804807
protected def force(x: AnyRef) = preBody = x
@@ -812,22 +815,22 @@ object Trees {
812815
case class Import[-T >: Untyped] private[ast] (expr: Tree[T], selectors: List[Tree[Untyped]])
813816
extends DenotingTree[T] {
814817
type ThisTree[-T >: Untyped] = Import[T]
815-
def tag = Tag.Import
818+
final def tag = Tag.Import
816819
}
817820

818821
/** package pid { stats } */
819822
case class PackageDef[-T >: Untyped] private[ast] (pid: RefTree[T], stats: List[Tree[T]])
820823
extends ProxyTree[T] {
821824
type ThisTree[-T >: Untyped] = PackageDef[T]
822-
def tag = Tag.PackageDef
825+
final def tag = Tag.PackageDef
823826
def forwardTo = pid
824827
}
825828

826829
/** arg @annot */
827830
case class Annotated[-T >: Untyped] private[ast] (arg: Tree[T], annot: Tree[T])
828831
extends ProxyTree[T] {
829832
type ThisTree[-T >: Untyped] = Annotated[T]
830-
def tag = Tag.Annotated
833+
final def tag = Tag.Annotated
831834
def forwardTo = arg
832835
}
833836

@@ -846,7 +849,7 @@ object Trees {
846849
case class Thicket[-T >: Untyped](trees: List[Tree[T]])
847850
extends Tree[T] with WithoutTypeOrPos[T] {
848851
type ThisTree[-T >: Untyped] = Thicket[T]
849-
def tag = Tag.Thicket
852+
final def tag = Tag.Thicket
850853
override def isEmpty: Boolean = trees.isEmpty
851854
override def toList: List[Tree[T]] = flatten(trees)
852855
override def toString = if (isEmpty) "EmptyTree" else "Thicket(" + trees.mkString(", ") + ")"

0 commit comments

Comments
 (0)