Skip to content

Commit 2c45db3

Browse files
oderskyodersky
committed
Make TreeCopiers preserve source
Copies should have the same source attribute as originals.
1 parent 3abb296 commit 2c45db3

File tree

2 files changed

+90
-86
lines changed

2 files changed

+90
-86
lines changed

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

Lines changed: 51 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,7 @@ import language.higherKinds
99
import collection.mutable.ListBuffer
1010
import printing.Printer
1111
import printing.Texts.Text
12-
import util.{Stats, Attachment, Property}
12+
import util.{Stats, Attachment, Property, SourceFile}
1313
import config.Config
1414
import annotation.internal.sharable
1515
import annotation.unchecked.uncheckedVariance
@@ -66,6 +66,8 @@ object Trees {
6666

6767
def uniqueId: Int = myUniqueId
6868

69+
def source(implicit ctx: Context): SourceFile = ctx.sourceOfTreeId(uniqueId)
70+
6971
/** The type constructor at the root of the tree */
7072
type ThisTree[T >: Untyped] <: Tree[T]
7173

@@ -980,19 +982,21 @@ object Trees {
980982
protected def finalize(tree: Tree, copied: untpd.MemberDef)(implicit ids:TreeIds): copied.ThisTree[T] =
981983
postProcess(tree, copied.withPos(tree.pos).withAttachmentsFrom(tree))
982984

985+
protected def srcCtx(tree: Tree)(implicit ctx: Context) = ctx.withSource(tree.source)
986+
983987
def Ident(tree: Tree)(name: Name)(implicit ctx: Context): Ident = tree match {
984988
case tree: BackquotedIdent =>
985989
if (name == tree.name) tree
986-
else finalize(tree, new BackquotedIdent(name))
990+
else finalize(tree, new BackquotedIdent(name)(srcCtx(tree)))
987991
case tree: Ident if name == tree.name => tree
988-
case _ => finalize(tree, untpd.Ident(name))
992+
case _ => finalize(tree, untpd.Ident(name)(srcCtx(tree)))
989993
}
990994
def Select(tree: Tree)(qualifier: Tree, name: Name)(implicit ctx: Context): Select = tree match {
991995
case tree: SelectWithSig =>
992996
if ((qualifier eq tree.qualifier) && (name == tree.name)) tree
993-
else finalize(tree, new SelectWithSig(qualifier, name, tree.sig))
997+
else finalize(tree, new SelectWithSig(qualifier, name, tree.sig)(srcCtx(tree)))
994998
case tree: Select if (qualifier eq tree.qualifier) && (name == tree.name) => tree
995-
case _ => finalize(tree, untpd.Select(qualifier, name))
999+
case _ => finalize(tree, untpd.Select(qualifier, name)(srcCtx(tree)))
9961000
}
9971001
/** Copy Ident or Select trees */
9981002
def Ref(tree: RefTree)(name: Name)(implicit ctx: Context): RefTree = tree match {
@@ -1001,168 +1005,168 @@ object Trees {
10011005
}
10021006
def This(tree: Tree)(qual: untpd.Ident)(implicit ctx: Context): This = tree match {
10031007
case tree: This if qual eq tree.qual => tree
1004-
case _ => finalize(tree, untpd.This(qual))
1008+
case _ => finalize(tree, untpd.This(qual)(srcCtx(tree)))
10051009
}
10061010
def Super(tree: Tree)(qual: Tree, mix: untpd.Ident)(implicit ctx: Context): Super = tree match {
10071011
case tree: Super if (qual eq tree.qual) && (mix eq tree.mix) => tree
1008-
case _ => finalize(tree, untpd.Super(qual, mix))
1012+
case _ => finalize(tree, untpd.Super(qual, mix)(srcCtx(tree)))
10091013
}
10101014
def Apply(tree: Tree)(fun: Tree, args: List[Tree])(implicit ctx: Context): Apply = tree match {
10111015
case tree: Apply if (fun eq tree.fun) && (args eq tree.args) => tree
1012-
case _ => finalize(tree, untpd.Apply(fun, args))
1016+
case _ => finalize(tree, untpd.Apply(fun, args)(srcCtx(tree)))
10131017
}
10141018
def TypeApply(tree: Tree)(fun: Tree, args: List[Tree])(implicit ctx: Context): TypeApply = tree match {
10151019
case tree: TypeApply if (fun eq tree.fun) && (args eq tree.args) => tree
1016-
case _ => finalize(tree, untpd.TypeApply(fun, args))
1020+
case _ => finalize(tree, untpd.TypeApply(fun, args)(srcCtx(tree)))
10171021
}
10181022
def Literal(tree: Tree)(const: Constant)(implicit ctx: Context): Literal = tree match {
10191023
case tree: Literal if const == tree.const => tree
1020-
case _ => finalize(tree, untpd.Literal(const))
1024+
case _ => finalize(tree, untpd.Literal(const)(srcCtx(tree)))
10211025
}
10221026
def New(tree: Tree)(tpt: Tree)(implicit ctx: Context): New = tree match {
10231027
case tree: New if tpt eq tree.tpt => tree
1024-
case _ => finalize(tree, untpd.New(tpt))
1028+
case _ => finalize(tree, untpd.New(tpt)(srcCtx(tree)))
10251029
}
10261030
def Typed(tree: Tree)(expr: Tree, tpt: Tree)(implicit ctx: Context): Typed = tree match {
10271031
case tree: Typed if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
1028-
case _ => finalize(tree, untpd.Typed(expr, tpt))
1032+
case _ => finalize(tree, untpd.Typed(expr, tpt)(srcCtx(tree)))
10291033
}
10301034
def NamedArg(tree: Tree)(name: Name, arg: Tree)(implicit ctx: Context): NamedArg = tree match {
10311035
case tree: NamedArg if (name == tree.name) && (arg eq tree.arg) => tree
1032-
case _ => finalize(tree, untpd.NamedArg(name, arg))
1036+
case _ => finalize(tree, untpd.NamedArg(name, arg)(srcCtx(tree)))
10331037
}
10341038
def Assign(tree: Tree)(lhs: Tree, rhs: Tree)(implicit ctx: Context): Assign = tree match {
10351039
case tree: Assign if (lhs eq tree.lhs) && (rhs eq tree.rhs) => tree
1036-
case _ => finalize(tree, untpd.Assign(lhs, rhs))
1040+
case _ => finalize(tree, untpd.Assign(lhs, rhs)(srcCtx(tree)))
10371041
}
10381042
def Block(tree: Tree)(stats: List[Tree], expr: Tree)(implicit ctx: Context): Block = tree match {
10391043
case tree: Block if (stats eq tree.stats) && (expr eq tree.expr) => tree
1040-
case _ => finalize(tree, untpd.Block(stats, expr))
1044+
case _ => finalize(tree, untpd.Block(stats, expr)(srcCtx(tree)))
10411045
}
10421046
def If(tree: Tree)(cond: Tree, thenp: Tree, elsep: Tree)(implicit ctx: Context): If = tree match {
10431047
case tree: If if (cond eq tree.cond) && (thenp eq tree.thenp) && (elsep eq tree.elsep) => tree
1044-
case tree: InlineIf => finalize(tree, untpd.InlineIf(cond, thenp, elsep))
1045-
case _ => finalize(tree, untpd.If(cond, thenp, elsep))
1048+
case tree: InlineIf => finalize(tree, untpd.InlineIf(cond, thenp, elsep)(srcCtx(tree)))
1049+
case _ => finalize(tree, untpd.If(cond, thenp, elsep)(srcCtx(tree)))
10461050
}
10471051
def Closure(tree: Tree)(env: List[Tree], meth: Tree, tpt: Tree)(implicit ctx: Context): Closure = tree match {
10481052
case tree: Closure if (env eq tree.env) && (meth eq tree.meth) && (tpt eq tree.tpt) => tree
1049-
case _ => finalize(tree, untpd.Closure(env, meth, tpt))
1053+
case _ => finalize(tree, untpd.Closure(env, meth, tpt)(srcCtx(tree)))
10501054
}
10511055
def Match(tree: Tree)(selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match = tree match {
10521056
case tree: Match if (selector eq tree.selector) && (cases eq tree.cases) => tree
1053-
case tree: InlineMatch => finalize(tree, untpd.InlineMatch(selector, cases))
1054-
case _ => finalize(tree, untpd.Match(selector, cases))
1057+
case tree: InlineMatch => finalize(tree, untpd.InlineMatch(selector, cases)(srcCtx(tree)))
1058+
case _ => finalize(tree, untpd.Match(selector, cases)(srcCtx(tree)))
10551059
}
10561060
def CaseDef(tree: Tree)(pat: Tree, guard: Tree, body: Tree)(implicit ctx: Context): CaseDef = tree match {
10571061
case tree: CaseDef if (pat eq tree.pat) && (guard eq tree.guard) && (body eq tree.body) => tree
1058-
case _ => finalize(tree, untpd.CaseDef(pat, guard, body))
1062+
case _ => finalize(tree, untpd.CaseDef(pat, guard, body)(srcCtx(tree)))
10591063
}
10601064
def Labeled(tree: Tree)(bind: Bind, expr: Tree)(implicit ctx: Context): Labeled = tree match {
10611065
case tree: Labeled if (bind eq tree.bind) && (expr eq tree.expr) => tree
1062-
case _ => finalize(tree, untpd.Labeled(bind, expr))
1066+
case _ => finalize(tree, untpd.Labeled(bind, expr)(srcCtx(tree)))
10631067
}
10641068
def Return(tree: Tree)(expr: Tree, from: Tree)(implicit ctx: Context): Return = tree match {
10651069
case tree: Return if (expr eq tree.expr) && (from eq tree.from) => tree
1066-
case _ => finalize(tree, untpd.Return(expr, from))
1070+
case _ => finalize(tree, untpd.Return(expr, from)(srcCtx(tree)))
10671071
}
10681072
def WhileDo(tree: Tree)(cond: Tree, body: Tree)(implicit ctx: Context): WhileDo = tree match {
10691073
case tree: WhileDo if (cond eq tree.cond) && (body eq tree.body) => tree
1070-
case _ => finalize(tree, untpd.WhileDo(cond, body))
1074+
case _ => finalize(tree, untpd.WhileDo(cond, body)(srcCtx(tree)))
10711075
}
10721076
def Try(tree: Tree)(expr: Tree, cases: List[CaseDef], finalizer: Tree)(implicit ctx: Context): Try = tree match {
10731077
case tree: Try if (expr eq tree.expr) && (cases eq tree.cases) && (finalizer eq tree.finalizer) => tree
1074-
case _ => finalize(tree, untpd.Try(expr, cases, finalizer))
1078+
case _ => finalize(tree, untpd.Try(expr, cases, finalizer)(srcCtx(tree)))
10751079
}
10761080
def SeqLiteral(tree: Tree)(elems: List[Tree], elemtpt: Tree)(implicit ctx: Context): SeqLiteral = tree match {
10771081
case tree: JavaSeqLiteral =>
10781082
if ((elems eq tree.elems) && (elemtpt eq tree.elemtpt)) tree
10791083
else finalize(tree, new JavaSeqLiteral(elems, elemtpt))
10801084
case tree: SeqLiteral if (elems eq tree.elems) && (elemtpt eq tree.elemtpt) => tree
1081-
case _ => finalize(tree, untpd.SeqLiteral(elems, elemtpt))
1085+
case _ => finalize(tree, untpd.SeqLiteral(elems, elemtpt)(srcCtx(tree)))
10821086
}
10831087
def Inlined(tree: Tree)(call: tpd.Tree, bindings: List[MemberDef], expansion: Tree)(implicit ctx: Context): Inlined = tree match {
10841088
case tree: Inlined if (call eq tree.call) && (bindings eq tree.bindings) && (expansion eq tree.expansion) => tree
1085-
case _ => finalize(tree, untpd.Inlined(call, bindings, expansion))
1089+
case _ => finalize(tree, untpd.Inlined(call, bindings, expansion)(srcCtx(tree)))
10861090
}
10871091
def SingletonTypeTree(tree: Tree)(ref: Tree)(implicit ctx: Context): SingletonTypeTree = tree match {
10881092
case tree: SingletonTypeTree if ref eq tree.ref => tree
1089-
case _ => finalize(tree, untpd.SingletonTypeTree(ref))
1093+
case _ => finalize(tree, untpd.SingletonTypeTree(ref)(srcCtx(tree)))
10901094
}
10911095
def AndTypeTree(tree: Tree)(left: Tree, right: Tree)(implicit ctx: Context): AndTypeTree = tree match {
10921096
case tree: AndTypeTree if (left eq tree.left) && (right eq tree.right) => tree
1093-
case _ => finalize(tree, untpd.AndTypeTree(left, right))
1097+
case _ => finalize(tree, untpd.AndTypeTree(left, right)(srcCtx(tree)))
10941098
}
10951099
def OrTypeTree(tree: Tree)(left: Tree, right: Tree)(implicit ctx: Context): OrTypeTree = tree match {
10961100
case tree: OrTypeTree if (left eq tree.left) && (right eq tree.right) => tree
1097-
case _ => finalize(tree, untpd.OrTypeTree(left, right))
1101+
case _ => finalize(tree, untpd.OrTypeTree(left, right)(srcCtx(tree)))
10981102
}
10991103
def RefinedTypeTree(tree: Tree)(tpt: Tree, refinements: List[Tree])(implicit ctx: Context): RefinedTypeTree = tree match {
11001104
case tree: RefinedTypeTree if (tpt eq tree.tpt) && (refinements eq tree.refinements) => tree
1101-
case _ => finalize(tree, untpd.RefinedTypeTree(tpt, refinements))
1105+
case _ => finalize(tree, untpd.RefinedTypeTree(tpt, refinements)(srcCtx(tree)))
11021106
}
11031107
def AppliedTypeTree(tree: Tree)(tpt: Tree, args: List[Tree])(implicit ctx: Context): AppliedTypeTree = tree match {
11041108
case tree: AppliedTypeTree if (tpt eq tree.tpt) && (args eq tree.args) => tree
1105-
case _ => finalize(tree, untpd.AppliedTypeTree(tpt, args))
1109+
case _ => finalize(tree, untpd.AppliedTypeTree(tpt, args)(srcCtx(tree)))
11061110
}
11071111
def LambdaTypeTree(tree: Tree)(tparams: List[TypeDef], body: Tree)(implicit ctx: Context): LambdaTypeTree = tree match {
11081112
case tree: LambdaTypeTree if (tparams eq tree.tparams) && (body eq tree.body) => tree
1109-
case _ => finalize(tree, untpd.LambdaTypeTree(tparams, body))
1113+
case _ => finalize(tree, untpd.LambdaTypeTree(tparams, body)(srcCtx(tree)))
11101114
}
11111115
def MatchTypeTree(tree: Tree)(bound: Tree, selector: Tree, cases: List[CaseDef])(implicit ctx: Context): MatchTypeTree = tree match {
11121116
case tree: MatchTypeTree if (bound eq tree.bound) && (selector eq tree.selector) && (cases eq tree.cases) => tree
1113-
case _ => finalize(tree, untpd.MatchTypeTree(bound, selector, cases))
1117+
case _ => finalize(tree, untpd.MatchTypeTree(bound, selector, cases)(srcCtx(tree)))
11141118
}
11151119
def ByNameTypeTree(tree: Tree)(result: Tree)(implicit ctx: Context): ByNameTypeTree = tree match {
11161120
case tree: ByNameTypeTree if result eq tree.result => tree
1117-
case _ => finalize(tree, untpd.ByNameTypeTree(result))
1121+
case _ => finalize(tree, untpd.ByNameTypeTree(result)(srcCtx(tree)))
11181122
}
11191123
def TypeBoundsTree(tree: Tree)(lo: Tree, hi: Tree)(implicit ctx: Context): TypeBoundsTree = tree match {
11201124
case tree: TypeBoundsTree if (lo eq tree.lo) && (hi eq tree.hi) => tree
1121-
case _ => finalize(tree, untpd.TypeBoundsTree(lo, hi))
1125+
case _ => finalize(tree, untpd.TypeBoundsTree(lo, hi)(srcCtx(tree)))
11221126
}
11231127
def Bind(tree: Tree)(name: Name, body: Tree)(implicit ctx: Context): Bind = tree match {
11241128
case tree: Bind if (name eq tree.name) && (body eq tree.body) => tree
1125-
case _ => finalize(tree, untpd.Bind(name, body))
1129+
case _ => finalize(tree, untpd.Bind(name, body)(srcCtx(tree)))
11261130
}
11271131
def Alternative(tree: Tree)(trees: List[Tree])(implicit ctx: Context): Alternative = tree match {
11281132
case tree: Alternative if trees eq tree.trees => tree
1129-
case _ => finalize(tree, untpd.Alternative(trees))
1133+
case _ => finalize(tree, untpd.Alternative(trees)(srcCtx(tree)))
11301134
}
11311135
def UnApply(tree: Tree)(fun: Tree, implicits: List[Tree], patterns: List[Tree])(implicit ctx: Context): UnApply = tree match {
11321136
case tree: UnApply if (fun eq tree.fun) && (implicits eq tree.implicits) && (patterns eq tree.patterns) => tree
1133-
case _ => finalize(tree, untpd.UnApply(fun, implicits, patterns))
1137+
case _ => finalize(tree, untpd.UnApply(fun, implicits, patterns)(srcCtx(tree)))
11341138
}
11351139
def ValDef(tree: Tree)(name: TermName, tpt: Tree, rhs: LazyTree)(implicit ctx: Context): ValDef = tree match {
11361140
case tree: ValDef if (name == tree.name) && (tpt eq tree.tpt) && (rhs eq tree.unforcedRhs) => tree
1137-
case _ => finalize(tree, untpd.ValDef(name, tpt, rhs))
1141+
case _ => finalize(tree, untpd.ValDef(name, tpt, rhs)(srcCtx(tree)))
11381142
}
11391143
def DefDef(tree: Tree)(name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: LazyTree)(implicit ctx: Context): DefDef = tree match {
11401144
case tree: DefDef if (name == tree.name) && (tparams eq tree.tparams) && (vparamss eq tree.vparamss) && (tpt eq tree.tpt) && (rhs eq tree.unforcedRhs) => tree
1141-
case _ => finalize(tree, untpd.DefDef(name, tparams, vparamss, tpt, rhs))
1145+
case _ => finalize(tree, untpd.DefDef(name, tparams, vparamss, tpt, rhs)(srcCtx(tree)))
11421146
}
11431147
def TypeDef(tree: Tree)(name: TypeName, rhs: Tree)(implicit ctx: Context): TypeDef = tree match {
11441148
case tree: TypeDef if (name == tree.name) && (rhs eq tree.rhs) => tree
1145-
case _ => finalize(tree, untpd.TypeDef(name, rhs))
1149+
case _ => finalize(tree, untpd.TypeDef(name, rhs)(srcCtx(tree)))
11461150
}
11471151
def Template(tree: Tree)(constr: DefDef, parents: List[Tree], self: ValDef, body: LazyTreeList)(implicit ctx: Context): Template = tree match {
11481152
case tree: Template if (constr eq tree.constr) && (parents eq tree.parents) && (self eq tree.self) && (body eq tree.unforcedBody) => tree
1149-
case _ => finalize(tree, untpd.Template(constr, parents, self, body))
1153+
case _ => finalize(tree, untpd.Template(constr, parents, self, body)(srcCtx(tree)))
11501154
}
11511155
def Import(tree: Tree)(expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import = tree match {
11521156
case tree: Import if (expr eq tree.expr) && (selectors eq tree.selectors) => tree
1153-
case _ => finalize(tree, untpd.Import(expr, selectors))
1157+
case _ => finalize(tree, untpd.Import(expr, selectors)(srcCtx(tree)))
11541158
}
11551159
def PackageDef(tree: Tree)(pid: RefTree, stats: List[Tree])(implicit ctx: Context): PackageDef = tree match {
11561160
case tree: PackageDef if (pid eq tree.pid) && (stats eq tree.stats) => tree
1157-
case _ => finalize(tree, untpd.PackageDef(pid, stats))
1161+
case _ => finalize(tree, untpd.PackageDef(pid, stats)(srcCtx(tree)))
11581162
}
11591163
def Annotated(tree: Tree)(arg: Tree, annot: Tree)(implicit ctx: Context): Annotated = tree match {
11601164
case tree: Annotated if (arg eq tree.arg) && (annot eq tree.annot) => tree
1161-
case _ => finalize(tree, untpd.Annotated(arg, annot))
1165+
case _ => finalize(tree, untpd.Annotated(arg, annot)(srcCtx(tree)))
11621166
}
11631167
def Thicket(tree: Tree)(trees: List[Tree])(implicit ctx: Context): Thicket = tree match {
11641168
case tree: Thicket if trees eq tree.trees => tree
1165-
case _ => finalize(tree, untpd.Thicket(trees))
1169+
case _ => finalize(tree, untpd.Thicket(trees)(srcCtx(tree)))
11661170
}
11671171

11681172
// Copier methods with default arguments; these demand that the original tree

0 commit comments

Comments
 (0)