untpd

Short-lived usage in typer, does not need copy/transform/fold infrastructure

A type tree that gets its type from some other tree's symbol. Enters the type tree in the References attachment of the from tree as a side effect.

An untyped template with a derives clause. Derived parents are added to the end of the parents list. derivedCount keeps track of how many there are. This representation was chosen because it balances two concerns:

• maximize overlap between DerivingTemplate and Template for code streamlining
• keep invariant that elements of untyped trees align with source positions

A function type

A function type with implicit, erased, or given modifiers

An enum to control checking or filtering of patterns in GenFrom trees

An interpolated string

Mod is intended to record syntactic information about modifiers, it's NOT a replacement of FlagSet.

For any query about semantic information, check flags instead.

Modifiers and annotations for definitions

mods object name impl

A polymorphic function type

A typed subtree of an untyped tree needs to be wrapped in a TypedSplice

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

A function created from a wildcard expression

A block generated by the XML parser, only treated specially by Positioned#checkPos

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

An extractor for trees of the form id or id: T

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.

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.

Info of a variable in a pattern: The named tree and its type

new T(args1)...(args_n) ==> new T.Ts...(args_n)

where Ts are the class type arguments of T or its class type alias. Note: we also keep any type arguments as parts of T. This is necessary to allow navigation into these arguments from the IDE, and to do the right thing in PrepareInlineable.

The context to use when mapping or accumulating over a tree

A new expression with constrictor and possibly type arguments. See New(tpt, argss) for details.

A reference to given definition. If definition is a repeated parameter, the reference will be a repeated argument.

A repeated argument such as arg: _*

All term arguments of an application in a single flattened list

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 largest subset of {NoInits, PureInterface} that a trait or class with this body can have as flags.

Does this CaseDef catch everything of a certain Type?

Does this CaseDef catch Throwable?

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.

Does this list contain a named argument tree?

For untyped trees, this is just the identity. For typed trees, a context derived form ctx that records call as the innermost enclosing call for which the inlined version is currently processed.

Is tree a backquoted identifier or definition

Is tree an context function or closure, possibly nested in a block?

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

Is this case guarded?

Is tree a path?

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

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

Is tree a super constructor call?

Is this parameter list a using clause?

Is tree a variable pattern?

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 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.

Hook to indicate that a transform of some subtree should be skipped

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

The context to use when transforming a tree. It ensures that the source is correct, and that the local context is used if that's necessary for transforming the whole tree. TODO: ensure transform is always called with the correct context as argument

The underlying pattern ignoring any bindings

The underlying tree when stripping any TypedSplice or Parens nodes

Property key for contextual Apply trees of the form fn given arg

Property key for TypeTrees marked with TypeRefOfSym or InfoOfSym which contains the symbol of the original tree from which this TypeTree is derived.

Property key containing TypeTrees whose type is computed from the symbol in this type. These type trees have marker trees TypeRefOfSym or InfoOfSym as their originals.