tpd

Map Inlined nodes, NamedArgs, Blocks with no statements and local references to underlying arguments. Also drops Inline and Block with no statements.

An extractor that pulls out type arguments

A trait for loaders that compute trees. Currently implemented just by DottyUnpickler.

Extractor for not-null assertions. A not-null assertion for reference x has the form x.$asInstanceOf$[x.type & T].

Fold f over all tree nodes, in depth-first, prefix order

Extractors for quotes

Fold f over all tree nodes, in depth-first, prefix order, but don't visit subtrees where f returns a different result for the root, i.e. f(x, root) ne x.

Extractors for splices

Extractors for type splices

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.

An extractor for closures, either contained in a block or standalone.

An extractor for def of a closure contained the block of the closure.

An anonymous class

new parents { forwarders }

where forwarders contains forwarders for all functions in fns.

A pattern corresponding to sym: tpe

A function def

vparams => expr

gets expanded to

{ def $anonfun(vparams) = expr; Closure($anonfun) }

where the closure's type is the target type of the expression (FunctionN, unless otherwise specified).

A DefDef with given method symbol sym.

A closure whole anonymous function has the given method type

An object def

object obs extends parents { decls }

gets expanded to

val obj = new obj$ class obj$ extends parents { this: obj.type => decls }

(The following no longer applies: What's interesting here is that the block is well typed (because class obj$ is hoistable), but the type of the obj val is not expressible. What needs to happen in general when inferring the type of a val from its RHS, is: if the type contains a class that has the val itself as owner, then that class is remapped to have the val's owner as owner. Remapping could be done by cloning the class with the new owner and substituting everywhere in the tree. We know that remapping is safe because the only way a local class can appear in the RHS of a val is by being hoisted outside of a block, and the necessary checks are done at this point already.

On the other hand, for method result type inference, if the type of the RHS of a method contains a class owned by the method, this would be an error.)

new C(args), calling the primary constructor of C

new C(args), calling given constructor constr of C

A _ with given type

Record inlined trees

A tree that corresponds to Predef.classOf[$tp] in source

Desugar identifier into a select node. Return the tree itself if not possible

Recover identifier prefix (e.g. this) if it exists

All enclosing calls that are currently inlined, from innermost to outermost.

Let bind tree unless tree is at least idempotent

The list of select trees that resolve to the same symbols as the ones that are imported by imp.

The symbols that are imported with expr.name

All the symbols that are imported by the first selector of imp that matches selectorPredicate.

Record an enclosing inlined call. EmptyTree calls (for parameters) cancel the next-enclosing call in the list instead of being added to it. We assume parameters are never nested inside parameters.

If tree's purity level is less than level, let-bind it so that it gets evaluated only once. I.e. produce a

{ val x = 'tree ; ~within('x) }

instead of otherwise

~within('tree)

The local context to use when traversing trees

The owner to be used in a local context when traversin a tree

Create a tree representing a list containing all the elements of the argument list. A "list of tree to tree of list" conversion.

Creates the nested pairs type tree repesentation of the type trees in ts

A tree representing a newXYZArray operation of the right kind for the given element type in elemTpe. No type arguments or length arguments are given.

A path that corresponds to the given type tp. Error if tp is not a refinement of an addressable singleton type.

Check if the limit on the number of inlined trees has been reached

A tree representing the same reference as the given type

Convert a list of trees to a vararg-compatible tree. Used to make arguments for methods that accept varargs.

Join stats in front of expr creating a new block if necessary

The source file where the symbol of the inline method referred to by call is defined

Split argument clauses into a leading type argument clause if it exists and remaining clauses

Creates the tuple type tree repesentation of the type trees in ts

A tree representing a wrapXYZArray(tree) operation of the right kind for the given element type in elemTpe.

The wrapped array method name for an array of type elemtp

The type and term arguments of a possibly curried call, in the order they are given

All type and value parameter symbols of this DefDef

Construct the application $receiver.$method[$targs]($args) using overloading resolution to find a matching overload of $method if necessary. This is useful when overloading resolution needs to be performed in a phase after typer. Note that this will not perform any kind of implicit search.

The (last) list of arguments of an application

Does this CaseDef catch everything of a certain Type?

Does this CaseDef catch Throwable?

If tree is a closure, its body, otherwise tree itself

(1) If tree is a constant expression, its value as a Literal, or tree itself otherwise.

Note: Demanding idempotency instead of purity in literalize is strictly speaking too loose. Example

object O { final val x = 42; println("43") } O.x

Strictly speaking we can't replace O.x with 42. But this would make most expressions non-constant. Maybe we can change the spec to accept this kind of eliding behavior. Or else enforce true purity in the compiler. The choice will be affected by what we will do with inline and with Singleton type bounds (see SIP 23). Presumably

object O1 { val x: Singleton = 42; println("43") } object O2 { inline val x = 42; println("43") }

should behave differently.

O1.x should have the same effect as { println("43"); 42 }

whereas

O2.x = 42

Revisit this issue once we have standardized on inline. Then we can demand purity of the prefix unless the selection goes to a inline val.

Note: This method should be applied to all term tree nodes that are not literals, that can be idempotent, and that can have constant types. So far, only nodes of the following classes qualify:

  Ident
  Select
  TypeApply

(2) A primitive unary operator expression pre.op where op is one of +, -, ~, ! that has a constant type ConstantType(v) but that is not a constant expression (i.e. pre has side-effects) is translated to

{ pre; v }

(3) An expression pre.getClass[..]() that has a constant type ConstantType(v) but where pre has side-effects is translated to:

{ pre; v }

This avoids the situation where we have a Select node that does not have a symbol.

Decompose a template body into parameters and other statements

Going from child to parent, the path of tree nodes that starts with a definition of symbol sym and ends with root, or Nil if no such path exists. Pre: sym must have a position.

If tree is a DefTree, the symbol defined by it, otherwise NoSymbol

The statement sequence that contains a definition of sym, or Nil if none was found. For a tree to be found, The symbol must have a position and its definition tree must be reachable from come tree stored in an enclosing context.

The purity level of this expression. See docs for PurityLevel for what that means

Note that purity and idempotency are treated differently. References to modules and lazy vals are impure (side-effecting) both because side-effecting code may be executed and because the first reference takes a different code path than all to follow; but they are idempotent because running the expression a second time gives the cached result.

The first constructor definition in stats

Checks whether predicate p is true for all result parts of this expression, where we zoom into Ifs, Matches, and Blocks.

The function part of a possibly curried call. Unlike methPart this one does not decompose blocks

Does this list contain a named argument tree?

Is tree a backquoted identifier or definition

Is this pattern node a catch-all or type-test pattern?

Is this pattern node a catch-all (wildcard or variable) pattern?

Is this case guarded?

Is tree a path?

Is the application tree with function part fn known to be pure? Function value and arguments can still be impure.

Is tpt a vararg type of the form T* or => T*?

Is tree a this node which belongs to enclClass?

Is tree a self constructor call this(...)? I.e. a call to a constructor of the same object?

Is this a (potentially applied) selection of a member of a structural type that is not a member of an underlying class or trait?

Is tree a super constructor call?

Is this pattern node a synthetic catch-all case, added during PartialFuction synthesis before we know whether the user provided cases are exhaustive.

Is this parameter list a using clause?

Is tree a variable pattern?

Is tree a reference to a mutable variable, or to a potential getter that has a setter in the same class?

Is the argument a wildcard argument of the form _ or x @ _?

Is this argument node of the form *, or is it a reference to such an argument ? The latter case can happen when an argument is lifted.

Does this argument list end with an argument of the form : _* ?

If tparams is non-empty, add it to the left paramss, merging it with a leading type parameter list of paramss, if one exists.

If path looks like a language import, Some(name) where name is experimental if that sub-module is imported, and the empty term name otherwise.

The symbols defined locally in a statement list

Is symbol potentially a getter of a mutable variable?

The method part of an application node, possibly enclosed in a block with only valdefs as statements. the reason for also considering blocks is that named arguments can transform a call into a block, e.g. (b = foo, a = bar) is transformed to { val x$1 = foo val x$2 = bar (x$2, x$1) }

The number of arguments in an application

The largest subset of {NoInits, PureInterface} that a trait or class with these parents can have as flags.

The variables defined by a pattern, in reverse order of their appearance.

The qualifier part of a Select or Ident. For an Ident, this is the This of the current class.

The purity level of this reference.

The tree containing only the top-level classes and objects matching either cls or its companion object

Return a pair consisting of (supercall, rest)

• supercall: the superclass call, excluding trait constr calls

The supercall is always the first statement (if it exists)

The purity level of this statement.

If this is an application, its function part, stripping all Apply nodes (but leaving TypeApply nodes in). Otherwise the tree itself.

If this is a block, its expression part

Strips layers of .asInstanceOf[T] / _.$asInstanceOf[T]() from an expression

The term arguments of a possibly curried call

The top level classes in this tree, including only those module classes that are not a linked class of some other class in the result.

If tree is an instance of TupleN[...](e1, ..., eN), the arguments e1, ..., eN otherwise the empty list.

The type arguments of a possibly curried call

The underlying pattern ignoring any bindings