tree_1 | ... | tree_n

tree_1 | ... | tree_n

left & right

left & right

arg @annot

arg @annot

tpt[args]

tpt[args]

fun(args)

fun(args)

name = arg, outside a parameter list

name = arg, outside a parameter list

name @ body

name @ body

{ stats; expr }

{ stats; expr }

=> T

=> T

case pat if guard => body; only appears as child of a Match

case pat if guard => body; only appears as child of a Match

A closure with an environment and a reference to a method.

A closure with an environment and a reference to a method.

mods def nametparams...(vparams_n): tpt = rhs

mods def nametparams...(vparams_n): tpt = rhs

Tree defines a new symbol

Tree's denotation can be derived from its type

name

name

if cond then thenp else elsep

if cond then thenp else elsep

import expr.selectors where a selector is either an untyped Ident, name or an untyped thicket consisting of name and rename.

import expr.selectors where a selector is either an untyped Ident, name or an untyped thicket consisting of name and rename.

A tree representing inlined code.

A tree representing inlined code.

Array(elems)

[typeparams] -> tpt

[typeparams] -> tpt

A base trait for lazy tree fields. These can be instantiated with Lazy instances which can delay tree construction until the field is first demanded.

const

const

selector match { cases }

selector match { cases }

Tree defines a new symbol and carries modifiers. The position of a MemberDef contains only the defined identifier or pattern. The envelope of a MemberDef contains the whole definition and has its point on the opening keyword (or the next token after that if keyword is missing).

Tree has a name

name = arg, in a parameter list

name = arg, in a parameter list

new tpt, but no constructor call

new tpt, but no constructor call

left | right

left | right

package pid { stats }

package pid { stats }

Instances of this class are trees which are not terms but are legal parts of patterns.

Tree's denot/isType/isTerm properties come from a subtree identified by forwardTo.

Tree refers by name to a denotation

tpt { refinements }

tpt { refinements }

return expr where from refers to the method from which the return takes place After program transformations this is not necessarily the enclosing method, because closures can intervene.

return expr where from refers to the method from which the return takes place After program transformations this is not necessarily the enclosing method, because closures can intervene.

qualifier.name, or qualifier#name, if qualifier is a type

qualifier.name, or qualifier#name, if qualifier is a type

Seq(elems)

Seq(elems)

ref.type

ref.type

C.super[mix], where qual = C.this

C.super[mix], where qual = C.this

extends parents { self => body }

extends parents { self => body }

Instances of this class are trees for which isTerm is definitely true. Note that some trees have isTerm = true without being TermTrees (e.g. Ident, AnnotatedTree)

Temporary class that results from translation of ModuleDefs (and possibly other statements). The contained trees will be integrated when transformed with a transform(List[Tree]) call.

Temporary class that results from translation of ModuleDefs (and possibly other statements). The contained trees will be integrated when transformed with a transform(List[Tree]) call.

qual.this

qual.this

Trees take a parameter indicating what the type of their tpe field is. Two choices: Type or Untyped. Untyped trees have type Tree[Untyped].

Tree typing uses a copy-on-write implementation:

• You can never observe a tpe which is null (throws an exception)
• So when creating a typed tree with withType we can re-use the existing tree transparently, assigning its tpe field, provided it was null before.
• It is impossible to embed untyped trees in typed ones.
• Typed trees can be embedded in untyped ones provided they are rooted in a TypedSplice node.
• Type checking an untyped tree should remove all embedded TypedSplice nodes.

try block catch handler finally finalizer

Note: if the handler is a case block CASES of the form

{ case1 ... caseN }

the parser returns Match(EmptyTree, CASES). Desugaring and typing this yields a closure node

{ def $anonfun(x: Throwable) = x match CASES; Closure(Nil, $anonfun) }

At some later stage when we normalize the try we can revert this to

Match(EmptyTree, CASES)

or else if stack is non-empty

Match(EmptyTree, <case x: Throwable => $anonfun(x)>)

try block catch handler finally finalizer

Note: if the handler is a case block CASES of the form

{ case1 ... caseN }

the parser returns Match(EmptyTree, CASES). Desugaring and typing this yields a closure node

{ def $anonfun(x: Throwable) = x match CASES; Closure(Nil, $anonfun) }

At some later stage when we normalize the try we can revert this to

Match(EmptyTree, CASES)

or else if stack is non-empty

Match(EmptyTree, <case x: Throwable => $anonfun(x)>)

Instances of this class are trees for which isType is definitely true. Note that some trees have isType = true without being TypTrees (e.g. Ident, AnnotatedTree)

fun[args]

fun[args]

: lo <: hi

: lo <: hi

mods class name template or mods trait name template or mods type name = rhs or mods type name >: lo <: hi, if rhs = TypeBoundsTree(lo, hi) & (lo ne hi)

mods class name template or mods trait name template or mods type name = rhs or mods type name >: lo <: hi, if rhs = TypeBoundsTree(lo, hi) & (lo ne hi)

A type tree that represents an existing or inferred type

A type tree that represents an existing or inferred type

expr : tpt

expr : tpt

The typed translation of extractor(patterns) in a pattern. The translation has the following components:

The typed translation of extractor(patterns) in a pattern. The translation has the following components:

mods val name: tpt = rhs

mods val name: tpt = rhs

A ValDef or DefDef tree

A tree that can have a lazy field The field is represented by some private var which is proxied unforced and force. Forcing the field will set the var to the underlying value.

Property key for trees with documentation strings attached

The total number of created tree nodes, maintained if Stats.enabled

The total number of created tree nodes, maintained if Stats.enabled