Trees
Related Doc:
package api
Alternatives of patterns, eliminated by explicitouter, except for occurrences in encoded Switch stmt (=remaining Match(CaseDef(...))
A tree that has an annotation attached to it.
A tree that has an annotation attached to it. Only used for annotated types and annotation ascriptions, annotations on definitions are stored in the Modifiers. Eliminated by typechecker (typedAnnotated), the annotations are then stored in an AnnotatedType.
Applied type <tpt> [ <args> ], eliminated by RefCheck
Value application
Dynamic value application.
Dynamic value application. In a dynamic application q.f(as)
Array of expressions, needs to be translated in backend,
Assignment
Bind of a variable to a rhs pattern, eliminated by explicitouter
Bind of a variable to a rhs pattern, eliminated by explicitouter
Block of expressions (semicolon separated expressions)
Case clause in a pattern match, eliminated during explicitouter (except for occurrences in switch statements)
A class definition.
Commented expression
Intersection type <parent1> with ...
Intersection type <parent1> with ... with <parentN> { <decls> }, eliminated by RefCheck
A method or macro definition.
A method or macro definition.
The name of the method or macro. Can be a type name in case this is a type macro
A tree which defines a symbol-carrying entity.
A tree for a function expression.
Anonymous function, eliminated by analyzer
Common base class for Apply and TypeApply.
Common base class for Apply and TypeApply. This could in principle be a SymTree, but whether or not a Tree is a SymTree isn't used to settle any interesting questions, and it would add a useless field to all the instances (useless, since GenericApply forwards to the underlying fun.)
Identifier <name>
Conditional expression
A common base class for class and object definitions.
Import clause
Import clause
Import selector
Import selector
Representation of an imported name its optional rename and their optional positions
the imported name
its position or -1 if undefined
the name the import is renamed to (== name if no renaming)
the position of the rename or -1 if undefined
Infix application
Infix extraction, for example case x :: rest
A labelled expression.
A labelled expression. Not expressible in language syntax, but generated by the compiler to simulate while/do-while loops, and also by the pattern matcher.
The label acts much like a nested function, where params represents
the incoming parameters. The symbol given to the LabelDef should have
a MethodType, as if it were a nested function.
Jumps are apply nodes attributed with a label's symbol. The arguments from the apply node will be passed to the label and assigned to the Idents.
Forward jumps within a block are allowed.
Literal
- Pattern matching expression (before explicitouter)
- Pattern matching expression (before explicitouter)
After explicitouter, cases will satisfy the following constraints:
EmptyTree,Literal(Constant(x:Int))
or Alternative(lit|...|lit)Ident(nme.WILDCARD)
Common base class for all member definitions: types, classes, objects, packages, vals and vars, defs.
An object definition, e.g.
An object definition, e.g. object Foo. Internally, objects are
quite frequently called modules to reduce ambiguity.
Object instantiation One should always use factory method below to build a user level new.
Object instantiation One should always use factory method below to build a user level new.
a class type
A packaging, such as package pid { stats }
A procedure definition.
A procedure definition. Sugar for a function whose return type is Unit.
The name of the method or macro. Can be a type name in case this is a type macro
A tree which references a symbol-carrying entity.
A tree which references a symbol-carrying entity. References one, as opposed to defining one; definitions are in DefTrees.
Return expression
Designator <qualifier> .
Designator <qualifier> . <name>
Type selection <qualifier> # <name>, eliminated by RefCheck
Singleton type, eliminated by RefCheck
Repetition of pattern, eliminated by explicitouter
Super reference, qual = corresponding this reference
A tree with a mutable symbol field, initialized to NoSymbol.
Instantiation template of a class or trait
Instantiation template of a class or trait
A tree for a term.
A tree for a term. Not all terms are TermTrees; use isTerm to reliably identify terms.
Self reference
Throw expression
Tree is the basis for scala's abstract syntax.
Tree is the basis for scala's abstract syntax. The nodes are implemented as case classes, and the parameters which initialize a given tree are immutable: however Trees have several mutable fields which are manipulated in the course of typechecking, including pos, symbol, and tpe.
Newly instantiated trees have tpe set to null (though it
may be set immediately thereafter depending on how it is
constructed.) When a tree is passed to the typer, typically via
typer.typed(tree), under normal circumstances the tpe must be
null or the typer will ignore it. Furthermore, the typer is not
required to return the same tree it was passed.
Trees can be easily traversed with e.g. foreach on the root node; for a more nuanced traversal, subclass Traverser. Transformations can be considerably trickier: see the numerous subclasses of Transformer found around the compiler.
Copying Trees should be done with care depending on whether it need be done lazily or strictly (see LazyTreeCopier and StrictTreeCopier) and on whether the contents of the mutable fields should be copied. The tree copiers will copy the mutable attributes to the new tree; calling Tree#duplicate will copy symbol and tpe, but all the positions will be focused.
Trees can be coarsely divided into four mutually exclusive categories:
TypTree, not TypeTree.SymTrees include important nodes Ident and Select, which are used as both terms and types; they are distinguishable based on whether the Name is a TermName or TypeName. The correct way for to test for a type or a term (on any Tree) are the isTerm/isType methods on Tree.
"Others" are mostly syntactic or short-lived constructs. Examples include CaseDef, which wraps individual match cases: they are neither terms nor types, nor do they carry a symbol. Another example is Parens, which is eliminated during parsing.
A tree for a type.
A tree for a type. Not all types are TypTrees; use isType to reliably identify types.
Explicit type application.
Explicit type application. All signs point toward it being a requirement that args.nonEmpty, but I can't find that explicitly stated anywhere. Unless your last name is odersky, you should probably treat it as true.
An abstract type, a type parameter, or a type alias.
A synthetic tree holding an arbitrary type.
A synthetic tree holding an arbitrary type. Not to be confused with
with TypTree, the trait for trees that are only used for type trees.
TypeTree's are inserted in several places, but most notably in
RefCheck, where the arbitrary type trees are all replaced by
TypeTree's.
Type annotation, eliminated by explicit outer
A constant value definition (this includes vars as well, which differ from vals only in having the MUTABLE flag set in their Modifiers.)
A common base class for ValDefs and DefDefs.
The empty tree