Trees

tree_1 | ... | tree_n

arg @annot

tpt[args]

fun(args)

The kind of application

name = arg, outside a parameter list

name @ body

{ stats; expr }

=> T

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

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

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

Tree defines a new symbol

Tree's denotation can be derived from its type

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

Tree that replaces a splice in pickled quotes. It is only used when picking quotes (Will never be in a TASTy file).

name

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.

A type tree whose type is inferred. These trees appear in two contexts

• as an argument of a TypeApply. In that case its type is always a TypeVar
• as a (result-)type of an inferred ValDef or DefDef. Every TypeVar is created as the type of one InferredTypeTree.

A tree representing inlined code.

Array(elems)

label[tpt]: { expr }

[typeparams] -> tpt

Note: the type of such a tree is not necessarily a HKTypeLambda, it can also be a TypeBounds where the upper bound is an HKTypeLambda, and the lower bound is either a reference to Nothing or an HKTypeLambda, this happens because these trees are typed by HKTypeLambda#fromParams which makes sure to move bounds outside of the type lambda itself to simplify their handling in the compiler.

You may ask: why not normalize the trees too? That way,

LambdaTypeTree(X, TypeBoundsTree(A, B))

would become,

TypeBoundsTree(LambdaTypeTree(X, A), LambdaTypeTree(X, B))

which would maintain consistency between a tree and its type. The problem with this definition is that the same tree X appears twice, therefore we'd have to create two symbols for it which makes it harder to relate the source code written by the user with the trees used by the compiler (for example, to make "find all references" work in the IDE).

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

selector match { cases }

[bound] 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

new tpt, but no constructor call

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 }

return expr where from refers to the method or label 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

Seq(elems)

ref.type

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

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, Annotated)

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

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 cases finally finalizer

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, Annotated)

fun[args]

: lo <: hi : lo <: hi = alias for RHS of bounded opaque type

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) or mods type name >: lo <: hi = rhs if rhs = TypeBoundsTree(lo, hi, alias) and opaque in mods

A type tree that represents an existing or inferred type

expr : tpt

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

mods val name: tpt = rhs

A ValDef or DefDef tree

while (cond) { body }

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

Property key for backquoted identifiers and definitions

Property key for trees with documentation strings attached

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