Universe
Related Doc:
package api
This class declares methods that are visible in a CompoundType (i.e.
This class declares methods that are visible in a CompoundType (i.e.
a class/trait/object template or refined type of the form
P_1 with ... with P_m { D_1; ...; D_n }
P_n
This class declares methods that are visible in a SingleType.
This class declares methods that are visible in a SingleType.
This class declares operations that are visible in a Type.
This class declares operations that are visible in a Type.
Alternatives of patterns, eliminated by explicitouter, except for occurrences in encoded Switch stmt (=remaining Match(CaseDef(...))
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
Applied type <tpt> [ <args> ], eliminated by RefCheck
Value application
Value application
Dynamic value application.
Dynamic value application. In a dynamic application q.f(as)
Array of expressions, needs to be translated in backend,
Array of expressions, needs to be translated in backend,
Assignment
Assignment
Bind of a variable to a rhs pattern, eliminated by explicitouter
Block of expressions (semicolon separated expressions)
Block of expressions (semicolon separated expressions)
Case clause in a pattern match, eliminated during explicitouter (except for occurrences in switch statements)
Case clause in a pattern match, eliminated during explicitouter (except for occurrences in switch statements)
A class definition.
A class definition.
The ClassInfo type signature is used to define parents and declarations
of classes, traits, and objects.
The ClassInfo type signature is used to define parents and declarations
of classes, traits, and objects. If a class, trait, or object C is declared like this
C extends P_1 with ... with P_m { D_1; ...; D_n}
its ClassInfo type has the following form:
ClassInfo(List(P_1, ..., P_m), Scope(D_1, ..., D_n), C)
An extractor class to create and pattern match with syntax ClassInfo(parents, decls, clazz)
Here, parents is the list of parent types of the class, decls is the scope
containing all declarations in the class, and clazz is the symbol of the class
itself.
An extractor class to create and pattern match with syntax ClassInfo(parents, decls, clazz)
Here, parents is the list of parent types of the class, decls is the scope
containing all declarations in the class, and clazz is the symbol of the class
itself.
Commented expression
Commented expression
A subtype of Type representing refined types as well as ClassInfo signatures.
A subtype of Type representing refined types as well as ClassInfo signatures.
Intersection type <parent1> with ...
Intersection type <parent1> with ... with <parentN> { <decls> }, eliminated by RefCheck
The ConstantType type is not directly written in user programs, but arises as the type of a constant.
The ConstantType type is not directly written in user programs, but arises as the type of a constant.
The REPL expresses constant types like Int(11). Here are some constants with their types.
1 ConstantType(Constant(1)) "abc" ConstantType(Constant("abc"))
An extractor class to create and pattern match with syntax ConstantType(constant)
Here, constant is the constant value represented by the type.
An extractor class to create and pattern match with syntax ConstantType(constant)
Here, constant is the constant value represented by the type.
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 which defines a symbol-carrying entity.
A tree for a function expression.
A tree for a function expression.
Anonymous function, eliminated by analyzer
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>
Identifier <name>
Conditional expression
Conditional expression
A common base class for class and object definitions.
A common base class for class and object definitions.
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 application
Infix extraction, for example case x :: rest
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
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.
Common base class for all member definitions: types, classes, objects, packages, vals and vars, defs.
The MethodType type signature is used to indicate parameters and result type of a method
The MethodType type signature is used to indicate parameters and result type of a method
An extractor class to create and pattern match with syntax MethodType(params, respte)
Here, params is a potentially empty list of parameter symbols of the method,
and restpe is the result type of the method.
An extractor class to create and pattern match with syntax MethodType(params, respte)
Here, params is a potentially empty list of parameter symbols of the method,
and restpe is the result type of the method. If the method is curried, restpe would
be another MethodType.
Note: MethodType(Nil, Int) would be the type of a method defined with an empty parameter list.
def f(): Int
If the method is completely parameterless, as in
def f: Int
its type is a NullaryMethodType.
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 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.
The RefinedType type defines types of any of the forms on the left,
with their RefinedType representations to the right.
The RefinedType type defines types of any of the forms on the left,
with their RefinedType representations to the right.
P_1 with ... with P_m { D_1; ...; D_n} RefinedType(List(P_1, ..., P_m), Scope(D_1, ..., D_n)) P_1 with ... with P_m RefinedType(List(P_1, ..., P_m), Scope()) { D_1; ...; D_n} RefinedType(List(AnyRef), Scope(D_1, ..., D_n))
An extractor class to create and pattern match with syntax RefinedType(parents, decls)
Here, parents is the list of parent types of the class, and decls is the scope
containing all declarations in the class.
An extractor class to create and pattern match with syntax RefinedType(parents, decls)
Here, parents is the list of parent types of the class, and decls is the scope
containing all declarations in the class.
Return expression
Return expression
Designator <qualifier> .
Designator <qualifier> . <name>
Type selection <qualifier> # <name>, eliminated by RefCheck
Type selection <qualifier> # <name>, eliminated by RefCheck
The SingleType type describes types of any of the forms on the left,
with their TypeRef representations to the right.
The SingleType type describes types of any of the forms on the left,
with their TypeRef representations to the right.
(T # x).type SingleType(T, x) p.x.type SingleType(p.type, x) x.type SingleType(NoPrefix, x)
An extractor class to create and pattern match with syntax SingleType(pre, sym)
Here, pre is the prefix of the single-type, and sym is the stable value symbol
referred to by the single-type.
An extractor class to create and pattern match with syntax SingleType(pre, sym)
Here, pre is the prefix of the single-type, and sym is the stable value symbol
referred to by the single-type.
The type of Scala singleton types, i.e.
The type of Scala singleton types, i.e. types that are inhabited by only one nun-null value. These include types of the forms
C.this.type C.super.type x.type
as well as constant types.
Singleton type, eliminated by RefCheck
Singleton type, eliminated by RefCheck
Repetition of pattern, eliminated by explicitouter
Repetition of pattern, eliminated by explicitouter
Super reference, qual = corresponding this reference
Super reference, qual = corresponding this reference
The SuperType type is not directly written, but arises when C.super is used
as a prefix in a TypeRef or SingleType.
The SuperType type is not directly written, but arises when C.super is used
as a prefix in a TypeRef or SingleType. It's internal presentation is
SuperType(thistpe, supertpe)
Here, thistpe is the type of the corresponding this-type. For instance,
in the type arising from C.super, the thistpe part would be ThisType(C).
supertpe is the type of the super class referred to by the super.
An extractor class to create and pattern match with syntax SingleType(thistpe, supertpe)
An extractor class to create and pattern match with syntax SingleType(thistpe, supertpe)
A tree with a mutable symbol field, initialized to NoSymbol.
A tree with a mutable symbol field, initialized to NoSymbol.
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
Self reference
The ThisType type describes types of the form on the left with the
correspnding ThisType representations to the right.
The ThisType type describes types of the form on the left with the
correspnding ThisType representations to the right.
C.this.type ThisType(C)
An extractor class to create and pattern match with syntax ThisType(sym)
where sym is the class prefix of the this type.
An extractor class to create and pattern match with syntax ThisType(sym)
where sym is the class prefix of the this type.
Throw expression
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.
The type of Scala types, and also Scala type signatures.
The type of Scala types, and also Scala type signatures. (No difference is internally made between the two).
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.
The TypeBounds type signature is used to indicate lower and upper type bounds
of type parameters and abstract types.
The TypeBounds type signature is used to indicate lower and upper type bounds
of type parameters and abstract types. It is not a first-class type.
If an abstract type or type parameter is declared with any of the forms
on the left, its type signature is the TypeBounds type on the right.
T >: L <: U TypeBounds(L, U) T >: L TypeBounds(L, Any) T <: U TypeBounds(Nothing, U)
An extractor class to create and pattern match with syntax TypeBound(lower, upper)
Here, lower is the lower bound of the TypeBounds pair, and upper is
the upper bound.
An extractor class to create and pattern match with syntax TypeBound(lower, upper)
Here, lower is the lower bound of the TypeBounds pair, and upper is
the upper bound.
An abstract type, a type parameter, or a type alias.
An abstract type, a type parameter, or a type alias.
The TypeRef type describes types of any of the forms on the left,
with their TypeRef representations to the right.
The TypeRef type describes types of any of the forms on the left,
with their TypeRef representations to the right.
T # C[T_1, ..., T_n] TypeRef(T, C, List(T_1, ..., T_n)) p.C[T_1, ..., T_n] TypeRef(p.type, C, List(T_1, ..., T_n)) C[T_1, ..., T_n] TypeRef(NoPrefix, C, List(T_1, ..., T_n)) T # C TypeRef(T, C, Nil) p.C TypeRef(p.type, C, Nil) C TypeRef(NoPrefix, C, Nil)
An extractor class to create and pattern match with syntax TypeRef(pre, sym, args)
Here, pre is the prefix of the type reference, sym is the symbol
referred to by the type reference, and args is a possible empty list of
type argumenrts.
An extractor class to create and pattern match with syntax TypeRef(pre, sym, args)
Here, pre is the prefix of the type reference, sym is the symbol
referred to by the type reference, and args is a possible empty list of
type argumenrts.
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
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 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.
A common base class for ValDefs and DefDefs.
The constructor/deconstructor for ClassInfoType instances.
The constructor/deconstructor for ClassInfoType instances.
The constructor/deconstructor for ConstantType instances.
The constructor/deconstructor for ConstantType instances.
The constructor/deconstructor for MethodType instances.
The constructor/deconstructor for MethodType instances.
This constant is used as a special value denoting the empty prefix in a path dependent type.
This constant is used as a special value denoting the empty prefix in a path dependent type.
For instance x.type is represented as SingleType(NoPrefix, <x>), where <x> stands for
the symbol for x.
This constant is used as a special value that indicates that no meaningful type exists.
This constant is used as a special value that indicates that no meaningful type exists.
The constructor/deconstructor for RefinedType instances.
The constructor/deconstructor for RefinedType instances.
The constructor/deconstructor for SingleType instances.
The constructor/deconstructor for SingleType instances.
The constructor/deconstructor for SuperType instances.
The constructor/deconstructor for SuperType instances.
The constructor/deconstructor for ThisType instances.
The constructor/deconstructor for ThisType instances.
The constructor/deconstructor for TypeBounds instances.
The constructor/deconstructor for TypeBounds instances.
The constructor/deconstructor for TypeRef instances.
The constructor/deconstructor for TypeRef instances.
Hook to define what show(tree) means.
Hook to define what show(tree) means.
The empty tree
The empty tree