abstract
class
TreeCopier
A class for copying trees. The copy methods avoid creating a new tree If all arguments stay the same.
Note: Some of the copy methods take a context. These are exactly those methods that are overridden in TypedTreeCopier so that they selectively retype themselves. Retyping needs a context.
Constructors
TreeCopier
(
)
Members
def
Alternative
(
tree:
Tree
)
(
trees:
List
[
Tree
]
)
: Alternative
def
AndTypeTree
(
tree:
Tree
)
(
left:
Tree
,
right:
Tree
)
: AndTypeTree
def
Annotated
(
tree:
Tree
)
(
arg:
Tree
,
annot:
Tree
)
(
implicit
ctx:
Context
)
: Annotated
def
AppliedTypeTree
(
tree:
Tree
)
(
tpt:
Tree
,
args:
List
[
Tree
]
)
: AppliedTypeTree
def
Apply
(
tree:
Tree
)
(
fun:
Tree
,
args:
List
[
Tree
]
)
(
implicit
ctx:
Context
)
: Apply
def
Assign
(
tree:
Tree
)
(
lhs:
Tree
,
rhs:
Tree
)
(
implicit
ctx:
Context
)
: Assign
def
Bind
(
tree:
Tree
)
(
name:
Name
,
body:
Tree
)
: Bind
def
Block
(
tree:
Tree
)
(
stats:
List
[
Tree
]
,
expr:
Tree
)
(
implicit
ctx:
Context
)
: Block
def
ByNameTypeTree
(
tree:
Tree
)
(
result:
Tree
)
: ByNameTypeTree
def
CaseDef
(
tree:
Tree
)
(
pat:
Tree
,
guard:
Tree
,
body:
Tree
)
(
implicit
ctx:
Context
)
: CaseDef
def
CaseDef
(
tree:
CaseDef
)
(
pat:
Tree
,
guard:
Tree
,
body:
Tree
)
(
implicit
ctx:
Context
)
: CaseDef
def
CaseDef$default$2
(
tree:
CaseDef
)
: Tree
[
T
]
def
CaseDef$default$3
(
tree:
CaseDef
)
: Tree
[
T
]
def
CaseDef$default$4
(
tree:
CaseDef
)
: Tree
[
T
]
def
Closure
(
tree:
Tree
)
(
env:
List
[
Tree
]
,
meth:
Tree
,
tpt:
Tree
)
(
implicit
ctx:
Context
)
: Closure
def
Closure
(
tree:
Closure
)
(
env:
List
[
Tree
]
,
meth:
Tree
,
tpt:
Tree
)
(
implicit
ctx:
Context
)
: Closure
def
Closure$default$2
(
tree:
Closure
)
: List
[
Tree
[
T
]
]
def
Closure$default$3
(
tree:
Closure
)
: Tree
[
T
]
def
Closure$default$4
(
tree:
Closure
)
: Tree
[
T
]
def
DefDef
(
tree:
Tree
)
(
name:
TermName
,
tparams:
List
[
TypeDef
]
,
vparamss:
List
[
List
[
ValDef
]
]
,
tpt:
Tree
,
rhs:
LazyTree
)
: DefDef
def
DefDef
(
tree:
DefDef
)
(
name:
TermName
,
tparams:
List
[
TypeDef
]
,
vparamss:
List
[
List
[
ValDef
]
]
,
tpt:
Tree
,
rhs:
LazyTree
)
: DefDef
def
DefDef$default$2
(
tree:
DefDef
)
: TermName
def
DefDef$default$3
(
tree:
DefDef
)
: List
[
TypeDef
[
T
]
]
def
DefDef$default$4
(
tree:
DefDef
)
: List
[
List
[
ValDef
[
T
]
]
]
def
DefDef$default$5
(
tree:
DefDef
)
: Tree
[
T
]
def
DefDef$default$6
(
tree:
DefDef
)
: LazyTree
def
Ident
(
tree:
Tree
)
(
name:
Name
)
: Ident
def
If
(
tree:
Tree
)
(
cond:
Tree
,
thenp:
Tree
,
elsep:
Tree
)
(
implicit
ctx:
Context
)
: If
def
If
(
tree:
If
)
(
cond:
Tree
,
thenp:
Tree
,
elsep:
Tree
)
(
implicit
ctx:
Context
)
: If
def
If$default$2
(
tree:
If
)
: Tree
[
T
]
def
If$default$3
(
tree:
If
)
: Tree
[
T
]
def
If$default$4
(
tree:
If
)
: Tree
[
T
]
def
Import
(
tree:
Tree
)
(
expr:
Tree
,
selectors:
List
[
Tree
]
)
: Import
def
Inlined
(
tree:
Tree
)
(
call:
Tree
,
bindings:
List
[
MemberDef
]
,
expansion:
Tree
)
(
implicit
ctx:
Context
)
: Inlined
def
Literal
(
tree:
Tree
)
(
const:
Constant
)
(
implicit
ctx:
Context
)
: Literal
def
Match
(
tree:
Tree
)
(
selector:
Tree
,
cases:
List
[
CaseDef
]
)
(
implicit
ctx:
Context
)
: Match
def
NamedArg
(
tree:
Tree
)
(
name:
Name
,
arg:
Tree
)
(
implicit
ctx:
Context
)
: NamedArg
def
New
(
tree:
Tree
)
(
tpt:
Tree
)
(
implicit
ctx:
Context
)
: New
def
OrTypeTree
(
tree:
Tree
)
(
left:
Tree
,
right:
Tree
)
: OrTypeTree
def
PackageDef
(
tree:
Tree
)
(
pid:
RefTree
,
stats:
List
[
Tree
]
)
: PackageDef
def
PolyTypeTree
(
tree:
Tree
)
(
tparams:
List
[
TypeDef
]
,
body:
Tree
)
: PolyTypeTree
def
Ref
(
tree:
RefTree
)
(
name:
Name
)
(
implicit
ctx:
Context
)
: Ident | Select
Copy Ident or Select trees
Copy Ident or Select trees
def
RefinedTypeTree
(
tree:
Tree
)
(
tpt:
Tree
,
refinements:
List
[
Tree
]
)
: RefinedTypeTree
def
Return
(
tree:
Tree
)
(
expr:
Tree
,
from:
Tree
)
(
implicit
ctx:
Context
)
: Return
def
Select
(
tree:
Tree
)
(
qualifier:
Tree
,
name:
Name
)
(
implicit
ctx:
Context
)
: Select
def
SeqLiteral
(
tree:
Tree
)
(
elems:
List
[
Tree
]
,
elemtpt:
Tree
)
(
implicit
ctx:
Context
)
: SeqLiteral
def
SingletonTypeTree
(
tree:
Tree
)
(
ref:
Tree
)
: SingletonTypeTree
def
Super
(
tree:
Tree
)
(
qual:
Tree
,
mix:
Ident
)
: Super
def
Template
(
tree:
Tree
)
(
constr:
DefDef
,
parents:
List
[
Tree
]
,
self:
ValDef
,
body:
LazyTreeList
)
: Template
def
Template
(
tree:
Template
)
(
constr:
DefDef
,
parents:
List
[
Tree
]
,
self:
ValDef
,
body:
LazyTreeList
)
: Template
def
Template$default$2
(
tree:
Template
)
: DefDef
[
T
]
def
Template$default$3
(
tree:
Template
)
: List
[
Tree
[
T
]
]
def
Template$default$4
(
tree:
Template
)
: ValDef
[
T
]
def
Template$default$5
(
tree:
Template
)
: AnyRef
def
Thicket
(
tree:
Tree
)
(
trees:
List
[
Tree
]
)
: Thicket
def
This
(
tree:
Tree
)
(
qual:
Ident
)
: This
def
Try
(
tree:
Tree
)
(
expr:
Tree
,
cases:
List
[
CaseDef
]
,
finalizer:
Tree
)
(
implicit
ctx:
Context
)
: Try
def
Try
(
tree:
Try
)
(
expr:
Tree
,
cases:
List
[
CaseDef
]
,
finalizer:
Tree
)
(
implicit
ctx:
Context
)
: Try
def
Try$default$2
(
tree:
Try
)
: Tree
[
T
]
def
Try$default$3
(
tree:
Try
)
: List
[
CaseDef
[
T
]
]
def
Try$default$4
(
tree:
Try
)
: Tree
[
T
]
def
TypeApply
(
tree:
Tree
)
(
fun:
Tree
,
args:
List
[
Tree
]
)
(
implicit
ctx:
Context
)
: TypeApply
def
TypeBoundsTree
(
tree:
Tree
)
(
lo:
Tree
,
hi:
Tree
)
: TypeBoundsTree
def
TypeDef
(
tree:
Tree
)
(
name:
TypeName
,
rhs:
Tree
)
: TypeDef
def
TypeDef
(
tree:
TypeDef
)
(
name:
TypeName
,
rhs:
Tree
)
: TypeDef
def
TypeDef$default$2
(
tree:
TypeDef
)
: TypeName
def
TypeDef$default$3
(
tree:
TypeDef
)
: Tree
[
T
]
def
Typed
(
tree:
Tree
)
(
expr:
Tree
,
tpt:
Tree
)
(
implicit
ctx:
Context
)
: Typed
def
UnApply
(
tree:
Tree
)
(
fun:
Tree
,
implicits:
List
[
Tree
]
,
patterns:
List
[
Tree
]
)
: UnApply
def
UnApply
(
tree:
UnApply
)
(
fun:
Tree
,
implicits:
List
[
Tree
]
,
patterns:
List
[
Tree
]
)
: UnApply
def
UnApply$default$2
(
tree:
UnApply
)
: Tree
[
T
]
def
UnApply$default$3
(
tree:
UnApply
)
: List
[
Tree
[
T
]
]
def
UnApply$default$4
(
tree:
UnApply
)
: List
[
Tree
[
T
]
]
def
ValDef
(
tree:
Tree
)
(
name:
TermName
,
tpt:
Tree
,
rhs:
LazyTree
)
: ValDef
def
ValDef
(
tree:
ValDef
)
(
name:
TermName
,
tpt:
Tree
,
rhs:
LazyTree
)
: ValDef
def
ValDef$default$2
(
tree:
ValDef
)
: TermName
def
ValDef$default$3
(
tree:
ValDef
)
: Tree
[
T
]
def
ValDef$default$4
(
tree:
ValDef
)
: LazyTree
def
finalize
(
tree:
Tree
,
copied:
Tree
)
: ThisTree
[
T
]
def
finalize
(
tree:
Tree
,
copied:
MemberDef
)
: ThisTree
[
T
]
def
postProcess
(
tree:
Tree
,
copied:
Tree
)
: ThisTree
[
T
]
def
postProcess
(
tree:
Tree
,
copied:
MemberDef
)
: ThisTree
[
T
]