trait JavaUniverse extends Universe
EXPERIMENTAL
A refinement of scala.reflect.api.Universe for runtime reflection using JVM classloaders.
This refinement equips mirrors with reflection capabilities for the JVM. JavaMirror
can
convert Scala reflection artifacts (symbols and types) into Java reflection artifacts (classes)
and vice versa. It can also perform reflective invocations (getting/setting field values,
calling methods, etc).
See the Reflection Guide for details on how to use runtime reflection.
- Self Type
- JavaUniverse
- Source
- JavaUniverse.scala
- Grouped
- Alphabetic
- By Inheritance
- JavaUniverse
- Universe
- Internals
- Quasiquotes
- Liftables
- Printers
- Mirrors
- StandardLiftables
- StandardNames
- StandardDefinitions
- ImplicitTags
- TypeTags
- Exprs
- Positions
- Annotations
- Constants
- Trees
- Names
- Scopes
- FlagSets
- Types
- Symbols
- AnyRef
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- All
Type Members
-
abstract
type
Annotation >: Null <: Universe.AnnotationApi
Information about an annotation.
Information about an annotation.
- Definition Classes
- Annotations
-
trait
AnnotationApi extends AnyRef
The API of
Annotation
instances.The API of
Annotation
instances. The main source of information about annotations is the scala.reflect.api.Annotations page.- Definition Classes
- Annotations
-
abstract
class
AnnotationExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Annotation(tpe, scalaArgs, javaArgs)
.An extractor class to create and pattern match with syntax
Annotation(tpe, scalaArgs, javaArgs)
. Here,tpe
is the annotation type,scalaArgs
the payload of Scala annotations, andjavaArgs
the payload of Java annotations.- Definition Classes
- Annotations
-
abstract
type
Constant >: Null <: Universe.ConstantApi
This "virtual" case class represents the reflection interface for literal expressions which can not be further broken down or evaluated, such as "true", "0", "classOf[List]".
This "virtual" case class represents the reflection interface for literal expressions which can not be further broken down or evaluated, such as "true", "0", "classOf[List]". Such values become parts of the Scala abstract syntax tree representing the program. The constants correspond to section 6.24 "Constant Expressions" of the Scala Language Specification.
Such constants are used to represent literals in abstract syntax trees (the scala.reflect.api.Trees#Literal node) and literal arguments for Java class file annotations (the scala.reflect.api.Annotations#LiteralArgument class).
Constants can be matched against and can be constructed directly, as if they were case classes:
assert(Constant(true).value == true) Constant(true) match { case Constant(s: String) => println("A string: " + s) case Constant(b: Boolean) => println("A boolean value: " + b) case Constant(x) => println("Something else: " + x) }
Constant
instances can wrap certain kinds of these expressions:- Literals of primitive value classes (
Byte
,Short
,Int
,Long
,Float
,Double
,Char
,Boolean
andUnit
) - represented directly as the corresponding type - String literals - represented as instances of the
String
. - References to classes, typically constructed with scala.Predef#classOf - represented as types.
- References to enumeration values - represented as symbols.
Class references are represented as instances of scala.reflect.api.Types#Type (because when the Scala compiler processes a class reference, the underlying runtime class might not yet have been compiled). To convert such a reference to a runtime class, one should use the
runtimeClass
method of a mirror such asRuntimeMirror
(the simplest way to get such a mirror is usingscala.reflect.runtime.currentMirror
).Enumeration value references are represented as instances of scala.reflect.api.Symbols#Symbol, which on JVM point to methods that return underlying enum values. To inspect an underlying enumeration or to get runtime value of a reference to an enum, one should use a scala.reflect.api.Mirrors#RuntimeMirror (the simplest way to get such a mirror is again scala.reflect.runtime.package#currentMirror).
Usage example:
enum JavaSimpleEnumeration { FOO, BAR } import java.lang.annotation.*; @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE}) public @interface JavaSimpleAnnotation { Class<?> classRef(); JavaSimpleEnumeration enumRef(); } @JavaSimpleAnnotation( classRef = JavaAnnottee.class, enumRef = JavaSimpleEnumeration.BAR ) public class JavaAnnottee {}
import scala.reflect.runtime.universe._ import scala.reflect.runtime.{currentMirror => cm} object Test extends App { val jann = typeOf[JavaAnnottee].typeSymbol.annotations(0).javaArgs def jarg(name: String) = jann(TermName(name)) match { // Constant is always wrapped into a Literal or LiteralArgument tree node case LiteralArgument(ct: Constant) => value case _ => sys.error("Not a constant") } val classRef = jarg("classRef").value.asInstanceOf[Type] // ideally one should match instead of casting println(showRaw(classRef)) // TypeRef(ThisType(
), JavaAnnottee, List()) println(cm.runtimeClass(classRef)) // class JavaAnnottee val enumRef = jarg("enumRef").value.asInstanceOf[Symbol] // ideally one should match instead of casting println(enumRef) // value BAR val siblings = enumRef.owner.info.decls val enumValues = siblings.filter(sym => sym.isVal && sym.isPublic) println(enumValues) // Scope{ // final val FOO: JavaSimpleEnumeration; // final val BAR: JavaSimpleEnumeration // } // doesn't work because of https://github.com/scala/bug/issues/6459 // val enumValue = mirror.reflectField(enumRef.asTerm).get val enumClass = cm.runtimeClass(enumRef.owner.asClass) val enumValue = enumClass.getDeclaredField(enumRef.name.toString).get(null) println(enumValue) // BAR }- Definition Classes
- Constants
- Literals of primitive value classes (
-
abstract
class
ConstantApi extends AnyRef
The API of Constant instances.
-
abstract
class
ConstantExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Constant(value)
wherevalue
is the Scala value of the constant.An extractor class to create and pattern match with syntax
Constant(value)
wherevalue
is the Scala value of the constant.- Definition Classes
- Constants
-
trait
Expr[+T] extends Equals with Serializable
Expr wraps an abstract syntax tree and tags it with its type.
Expr wraps an abstract syntax tree and tags it with its type. The main source of information about exprs is the scala.reflect.api.Exprs page.
- Definition Classes
- Exprs
-
trait
FlagOps extends Any
The API of
FlagSet
instances.The API of
FlagSet
instances. The main source of information about flag sets is the scala.reflect.api.FlagSets page.- Definition Classes
- FlagSets
-
abstract
type
FlagSet
An abstract type representing sets of flags (like private, final, etc.) that apply to definition trees and symbols
An abstract type representing sets of flags (like private, final, etc.) that apply to definition trees and symbols
- Definition Classes
- FlagSets
-
trait
FlagValues extends AnyRef
All possible values that can constitute flag sets.
All possible values that can constitute flag sets. The main source of information about flag sets is the scala.reflect.api.FlagSets page.
- Definition Classes
- FlagSets
- trait CompatApi extends AnyRef
-
class
CompatToken extends AnyRef
Presence of an implicit value of this type in scope indicates that source compatibility with Scala 2.10 has been enabled.
Presence of an implicit value of this type in scope indicates that source compatibility with Scala 2.10 has been enabled.
- Definition Classes
- Internals
- Annotations
- @implicitNotFound( ... )
-
abstract
type
FreeTermSymbol >: Null <: Universe.FreeTermSymbolApi with Universe.TermSymbol
The type of free terms introduced by reification.
The type of free terms introduced by reification.
- Definition Classes
- Internals
-
trait
FreeTermSymbolApi extends Universe.TermSymbolApi
The API of free term symbols.
-
abstract
type
FreeTypeSymbol >: Null <: Universe.FreeTypeSymbolApi with Universe.TypeSymbol
The type of free types introduced by reification.
The type of free types introduced by reification.
- Definition Classes
- Internals
-
trait
FreeTypeSymbolApi extends Universe.TypeSymbolApi
The API of free type symbols.
-
trait
Importer extends AnyRef
This trait provides support for importers, a facility to migrate reflection artifacts between universes.
This trait provides support for importers, a facility to migrate reflection artifacts between universes. Note: this trait should typically be used only rarely.
Reflection artifacts, such as Symbols and Types, are contained in Universes. Typically all processing happens within a single
Universe
(e.g. a compile-time macroUniverse
or a runtime reflectionUniverse
), but sometimes there is a need to migrate artifacts from oneUniverse
to another. For example, runtime compilation works by importing runtime reflection trees into a runtime compiler universe, compiling the importees and exporting the result back.Reflection artifacts are firmly grounded in their
Universe
s, which is reflected by the fact that types of artifacts from different universes are not compatible. By usingImporter
s, however, they be imported from one universe into another. For example, to importfoo.bar.Baz
from the sourceUniverse
to the targetUniverse
, an importer will first check whether the entire owner chain exists in the targetUniverse
. If it does, then nothing else will be done. Otherwise, the importer will recreate the entire owner chain and will import the corresponding type signatures into the targetUniverse
.Since importers match
Symbol
tables of the source and the targetUniverse
s using plain string names, it is programmer's responsibility to make sure that imports don't distort semantics, e.g., thatfoo.bar.Baz
in the sourceUniverse
means the same thatfoo.bar.Baz
does in the targetUniverse
.Example
Here's how one might implement a macro that performs compile-time evaluation of its argument by using a runtime compiler to compile and evaluate a tree that belongs to a compile-time compiler:
def staticEval[T](x: T) = macro staticEval[T] def staticEval[T](c: scala.reflect.macros.blackbox.Context)(x: c.Expr[T]) = { // creates a runtime reflection universe to host runtime compilation import scala.reflect.runtime.{universe => ru} val mirror = ru.runtimeMirror(c.libraryClassLoader) import scala.tools.reflect.ToolBox val toolBox = mirror.mkToolBox() // runtime reflection universe and compile-time macro universe are different // therefore an importer is needed to bridge them // currently mkImporter requires a cast to correctly assign the path-dependent types val importer0 = ru.internal.mkImporter(c.universe) val importer = importer0.asInstanceOf[ru.internal.Importer { val from: c.universe.type }] // the created importer is used to turn a compiler tree into a runtime compiler tree // both compilers use the same classpath, so semantics remains intact val imported = importer.importTree(tree) // after the tree is imported, it can be evaluated as usual val tree = toolBox.untypecheck(imported.duplicate) val valueOfX = toolBox.eval(imported).asInstanceOf[T] ... }
- Definition Classes
- Internals
-
trait
InternalApi extends AnyRef
Reflection API exhibits a tension inherent to experimental things: on the one hand we want it to grow into a beautiful and robust API, but on the other hand we have to deal with immaturity of underlying mechanisms by providing not very pretty solutions to enable important use cases.
Reflection API exhibits a tension inherent to experimental things: on the one hand we want it to grow into a beautiful and robust API, but on the other hand we have to deal with immaturity of underlying mechanisms by providing not very pretty solutions to enable important use cases.
In Scala 2.10, which was our first stab at reflection API, we didn't have a systematic approach to dealing with this tension, sometimes exposing too much of internals (e.g. Symbol.deSkolemize) and sometimes exposing too little (e.g. there's still no facility to change owners, to do typing transformations, etc). This resulted in certain confusion with some internal APIs living among public ones, scaring the newcomers, and some internal APIs only available via casting, which requires intimate knowledge of the compiler and breaks compatibility guarantees.
This led to creation of the
internal
API module for the reflection API, which provides advanced APIs necessary for macros that push boundaries of the state of the art, clearly demarcating them from the more or less straightforward rest and providing compatibility guarantees on par with the rest of the reflection API (full compatibility within minor releases, best effort towards backward compatibility within major releases, clear replacement path in case of rare incompatible changes in major releases).The
internal
module itself (the value that implements InternalApi) isn't defined here, in scala.reflect.api.Universe, but is provided on per-implementation basis. Runtime API endpoint (scala.reflect.runtime.universe) providesuniverse.compat: InternalApi
, whereas compile-time API endpoints (instances of scala.reflect.macros.Context) providec.compat: ContextInternalApi
, which extendsInternalApi
with additional universe-specific and context-specific functionality.- Definition Classes
- Internals
-
abstract
type
ReferenceToBoxed >: Null <: Universe.ReferenceToBoxedApi with Universe.TermTree
Marks underlying reference to id as boxed.
Marks underlying reference to id as boxed.
Precondition:<\b> id must refer to a captured variable A reference such marked will refer to the boxed entity, no dereferencing with `.elem` is done on it. This tree node can be emitted by macros such as reify that call referenceCapturedVariable. It is eliminated in LambdaLift, where the boxing conversion takes place.
- Definition Classes
- Internals
-
trait
ReferenceToBoxedApi extends Universe.TermTreeApi
The API that all references support
The API that all references support
- Definition Classes
- Internals
-
abstract
class
ReferenceToBoxedExtractor extends AnyRef
An extractor class to create and pattern match with syntax
ReferenceToBoxed(ident)
.An extractor class to create and pattern match with syntax
ReferenceToBoxed(ident)
. This AST node does not have direct correspondence to Scala code, and is emitted by macros to reference capture vars directly without going throughelem
.For example:
var x = ... fun { x }
Will emit:
Ident(x)
Which gets transformed to:
Select(Ident(x), "elem")
If
ReferenceToBoxed
were used instead of Ident, no transformation would be performed.- Definition Classes
- Internals
-
trait
ReificationSupportApi extends AnyRef
This is an internal implementation class.
This is an internal implementation class.
- Definition Classes
- Internals
- abstract type Compat <: CompatApi
-
abstract
type
Internal <: InternalApi
- Definition Classes
- Internals
- See also
-
trait
JavaMirror extends api.Mirror[JavaUniverse.this.type] with RuntimeMirror
A refinement of scala.reflect.api.Mirror for runtime reflection using JVM classloaders.
A refinement of scala.reflect.api.Mirror for runtime reflection using JVM classloaders.
With this upgrade, mirrors become capable of converting Scala reflection artifacts (symbols and types) into Java reflection artifacts (classes) and vice versa. Consequently, refined mirrors become capable of performing reflective invocations (getting/setting field values, calling methods, etc).
For more information about
Mirrors
s, see scala.reflect.api.Mirrors or the Reflection Guide: Mirrors -
abstract
type
Mirror >: Null <: JavaMirror
In runtime reflection universes, mirrors are
JavaMirrors
.In runtime reflection universes, mirrors are
JavaMirrors
.- Definition Classes
- JavaUniverse → Mirrors
-
abstract
type
Modifiers >: Null <: ModifiersApi
The type of tree modifiers (not a tree, but rather part of DefTrees).
The type of tree modifiers (not a tree, but rather part of DefTrees).
- Definition Classes
- Trees
-
abstract
type
Name >: Null <: NameApi
The abstract type of names.
The abstract type of names.
- Definition Classes
- Names
-
abstract
type
Position >: Null <: api.Position { type Pos = JavaUniverse.this.Position }
Defines a universe-specific notion of positions.
Defines a universe-specific notion of positions. The main documentation entry about positions is located at scala.reflect.api.Position.
- Definition Classes
- Positions
-
type
RuntimeClass = Class[_]
In runtime reflection universes, runtime representation of a class is
java.lang.Class
.In runtime reflection universes, runtime representation of a class is
java.lang.Class
.- Definition Classes
- JavaUniverse → Mirrors
-
abstract
type
TermName >: Null <: TermNameApi with Name
The abstract type of names representing types.
The abstract type of names representing types.
- Definition Classes
- Names
-
abstract
type
TypeName >: Null <: TypeNameApi with Name
The abstract type of names representing terms.
The abstract type of names representing terms.
- Definition Classes
- Names
-
trait
Liftable[T] extends AnyRef
A type class that defines a representation of
T
as aTree
.A type class that defines a representation of
T
as aTree
.- Definition Classes
- Liftables
- See also
http://docs.scala-lang.org/overviews/quasiquotes/lifting.html
-
trait
Unliftable[T] extends AnyRef
A type class that defines a way to extract instance of
T
from aTree
.A type class that defines a way to extract instance of
T
from aTree
.- Definition Classes
- Liftables
- See also
http://docs.scala-lang.org/overviews/quasiquotes/unlifting.html
-
trait
ClassMirror extends Universe.TemplateMirror
A mirror that reflects the instance parts of a runtime class.
A mirror that reflects the instance parts of a runtime class. See the overview page for details on how to use runtime reflection.
- Definition Classes
- Mirrors
-
trait
FieldMirror extends AnyRef
A mirror that reflects a field.
A mirror that reflects a field. See the overview page for details on how to use runtime reflection.
- Definition Classes
- Mirrors
-
trait
InstanceMirror extends AnyRef
A mirror that reflects a runtime value.
A mirror that reflects a runtime value. See the overview page for details on how to use runtime reflection.
- Definition Classes
- Mirrors
-
trait
MethodMirror extends AnyRef
A mirror that reflects a method.
A mirror that reflects a method. See the overview page for details on how to use runtime reflection.
- Definition Classes
- Mirrors
-
trait
ModuleMirror extends Universe.TemplateMirror
A mirror that reflects a Scala object definition or the static parts of a runtime class.
A mirror that reflects a Scala object definition or the static parts of a runtime class. See the overview page for details on how to use runtime reflection.
- Definition Classes
- Mirrors
-
trait
ReflectiveMirror extends api.Mirror[Mirrors.this.type]
A mirror that reflects instances and static classes.
A mirror that reflects instances and static classes. See the overview page for details on how to use runtime reflection.
- Definition Classes
- Mirrors
-
trait
RuntimeClassApi extends AnyRef
Has no special methods.
Has no special methods. Is here to provides erased identity for
RuntimeClass
.- Definition Classes
- Mirrors
-
trait
RuntimeMirror extends api.Mirror[Mirrors.this.type] with Universe.ReflectiveMirror
The API of a mirror for a reflective universe.
The API of a mirror for a reflective universe. See the overview page for details on how to use runtime reflection.
- Definition Classes
- Mirrors
-
trait
TemplateMirror extends AnyRef
A mirror that reflects the instance or static parts of a runtime class.
A mirror that reflects the instance or static parts of a runtime class. See the overview page for details on how to use runtime reflection.
- Definition Classes
- Mirrors
-
abstract
class
NameApi extends AnyRef
The API of Name instances.
The API of Name instances.
- Definition Classes
- Names
-
trait
TermNameApi extends AnyRef
Has no special methods.
Has no special methods. Is here to provides erased identity for
TermName
.- Definition Classes
- Names
-
abstract
class
TermNameExtractor extends AnyRef
An extractor class to create and pattern match with syntax
TermName(s)
.An extractor class to create and pattern match with syntax
TermName(s)
.- Definition Classes
- Names
-
trait
TypeNameApi extends AnyRef
Has no special methods.
Has no special methods. Is here to provides erased identity for
TypeName
.- Definition Classes
- Names
-
abstract
class
TypeNameExtractor extends AnyRef
An extractor class to create and pattern match with syntax
TypeName(s)
.An extractor class to create and pattern match with syntax
TypeName(s)
.- Definition Classes
- Names
-
case class
BooleanFlag(value: Option[Boolean]) extends Product with Serializable
- Definition Classes
- Printers
-
trait
TreePrinter extends AnyRef
- Attributes
- protected
- Definition Classes
- Printers
-
implicit
class
Quasiquote extends AnyRef
Implicit class that introduces
q
,tq
,cq,
pq
andfq
string interpolators that are also known as quasiquotes.Implicit class that introduces
q
,tq
,cq,
pq
andfq
string interpolators that are also known as quasiquotes. With their help you can easily manipulate Scala reflection ASTs.- Definition Classes
- Quasiquotes
- See also
-
abstract
type
MemberScope >: Null <: Universe.MemberScopeApi with Universe.Scope
The type of member scopes, as in class definitions, for example.
The type of member scopes, as in class definitions, for example.
- Definition Classes
- Scopes
-
trait
MemberScopeApi extends Universe.ScopeApi
The API that all member scopes support
The API that all member scopes support
- Definition Classes
- Scopes
-
abstract
type
Scope >: Null <: Universe.ScopeApi
The base type of all scopes.
The base type of all scopes.
- Definition Classes
- Scopes
-
trait
ScopeApi extends Iterable[Universe.Symbol]
The API that all scopes support
The API that all scopes support
- Definition Classes
- Scopes
-
trait
DefinitionsApi extends Universe.StandardTypes
Defines standard symbols (and types via its base trait).
Defines standard symbols (and types via its base trait).
- Definition Classes
- StandardDefinitions
-
trait
StandardTypes extends AnyRef
Defines standard types.
Defines standard types.
- Definition Classes
- StandardDefinitions
-
trait
StandardLiftableInstances extends AnyRef
- Definition Classes
- StandardLiftables
-
trait
StandardUnliftableInstances extends AnyRef
- Definition Classes
- StandardLiftables
-
trait
NamesApi extends AnyRef
Defines standard names, common for term and type names: These can be accessed via the nme and tpnme members.
Defines standard names, common for term and type names: These can be accessed via the nme and tpnme members.
- Definition Classes
- StandardNames
-
trait
TermNamesApi extends Universe.NamesApi
Defines standard term names that can be accessed via the nme member.
Defines standard term names that can be accessed via the nme member.
- Definition Classes
- StandardNames
-
trait
TypeNamesApi extends Universe.NamesApi
Defines standard type names that can be accessed via the tpnme member.
Defines standard type names that can be accessed via the tpnme member.
- Definition Classes
- StandardNames
-
abstract
type
ClassSymbol >: Null <: Universe.ClassSymbolApi with Universe.TypeSymbol
The type of class symbols representing class and trait definitions.
The type of class symbols representing class and trait definitions.
- Definition Classes
- Symbols
-
trait
ClassSymbolApi extends Universe.TypeSymbolApi
The API of class symbols.
The API of class symbols. The main source of information about symbols is the Symbols page.
Class Symbol defines
isXXX
test methods such asisPublic
orisFinal
,params
andreturnType
methods for method symbols,baseClasses
for class symbols and so on. Some of these methods don't make sense for certain subclasses ofSymbol
and returnNoSymbol
,Nil
or other empty values.- Definition Classes
- Symbols
-
abstract
type
MethodSymbol >: Null <: Universe.MethodSymbolApi with Universe.TermSymbol
The type of method symbols representing def declarations.
The type of method symbols representing def declarations.
- Definition Classes
- Symbols
-
trait
MethodSymbolApi extends Universe.TermSymbolApi
The API of method symbols.
The API of method symbols. The main source of information about symbols is the Symbols page.
Class Symbol defines
isXXX
test methods such asisPublic
orisFinal
,params
andreturnType
methods for method symbols,baseClasses
for class symbols and so on. Some of these methods don't make sense for certain subclasses ofSymbol
and returnNoSymbol
,Nil
or other empty values.- Definition Classes
- Symbols
-
abstract
type
ModuleSymbol >: Null <: Universe.ModuleSymbolApi with Universe.TermSymbol
The type of module symbols representing object declarations.
The type of module symbols representing object declarations.
- Definition Classes
- Symbols
-
trait
ModuleSymbolApi extends Universe.TermSymbolApi
The API of module symbols.
The API of module symbols. The main source of information about symbols is the Symbols page.
Class Symbol defines
isXXX
test methods such asisPublic
orisFinal
,params
andreturnType
methods for method symbols,baseClasses
for class symbols and so on. Some of these methods don't make sense for certain subclasses ofSymbol
and returnNoSymbol
,Nil
or other empty values.- Definition Classes
- Symbols
-
abstract
type
Symbol >: Null <: Universe.SymbolApi
The type of symbols representing declarations.
The type of symbols representing declarations.
- Definition Classes
- Symbols
-
trait
SymbolApi extends AnyRef
The API of symbols.
The API of symbols. The main source of information about symbols is the Symbols page.
Class Symbol defines
isXXX
test methods such asisPublic
orisFinal
,params
andreturnType
methods for method symbols,baseClasses
for class symbols and so on. Some of these methods don't make sense for certain subclasses ofSymbol
and returnNoSymbol
,Nil
or other empty values.- Definition Classes
- Symbols
-
abstract
type
TermSymbol >: Null <: Universe.TermSymbolApi with Universe.Symbol
The type of term symbols representing val, var, def, and object declarations as well as packages and value parameters.
The type of term symbols representing val, var, def, and object declarations as well as packages and value parameters.
- Definition Classes
- Symbols
-
trait
TermSymbolApi extends Universe.SymbolApi
The API of term symbols.
The API of term symbols. The main source of information about symbols is the Symbols page.
Class Symbol defines
isXXX
test methods such asisPublic
orisFinal
,params
andreturnType
methods for method symbols,baseClasses
for class symbols and so on. Some of these methods don't make sense for certain subclasses ofSymbol
and returnNoSymbol
,Nil
or other empty values.- Definition Classes
- Symbols
-
abstract
type
TypeSymbol >: Null <: Universe.TypeSymbolApi with Universe.Symbol
The type of type symbols representing type, class, and trait declarations, as well as type parameters.
The type of type symbols representing type, class, and trait declarations, as well as type parameters.
- Definition Classes
- Symbols
-
trait
TypeSymbolApi extends Universe.SymbolApi
The API of type symbols.
The API of type symbols. The main source of information about symbols is the Symbols page.
Class Symbol defines
isXXX
test methods such asisPublic
orisFinal
,params
andreturnType
methods for method symbols,baseClasses
for class symbols and so on. Some of these methods don't make sense for certain subclasses ofSymbol
and returnNoSymbol
,Nil
or other empty values.- Definition Classes
- Symbols
-
abstract
type
Alternative >: Null <: Universe.AlternativeApi with Universe.TermTree
Alternatives of patterns.
Alternatives of patterns.
Eliminated by compiler phases Eliminated by compiler phases patmat (in the new pattern matcher of 2.10) or explicitouter (in the old pre-2.10 pattern matcher), except for occurrences in encoded Switch stmt (i.e. remaining Match(CaseDef(...)))
- Definition Classes
- Trees
-
trait
AlternativeApi extends Universe.TermTreeApi
The API that all alternatives support
The API that all alternatives support
- Definition Classes
- Trees
-
abstract
class
AlternativeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Alternative(trees)
.An extractor class to create and pattern match with syntax
Alternative(trees)
. This AST node corresponds to the following Scala code:pat1 | ... | patn
- Definition Classes
- Trees
-
abstract
type
Annotated >: Null <: Universe.AnnotatedApi with Universe.Tree
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.
- Definition Classes
- Trees
-
trait
AnnotatedApi extends Universe.TreeApi
The API that all annotateds support
The API that all annotateds support
- Definition Classes
- Trees
-
abstract
class
AnnotatedExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Annotated(annot, arg)
.An extractor class to create and pattern match with syntax
Annotated(annot, arg)
. This AST node corresponds to the following Scala code:arg @annot // for types arg: @annot // for exprs
- Definition Classes
- Trees
-
abstract
type
AppliedTypeTree >: Null <: Universe.AppliedTypeTreeApi with Universe.TypTree
Applied type <tpt> [ <args> ], eliminated by RefCheck
Applied type <tpt> [ <args> ], eliminated by RefCheck
- Definition Classes
- Trees
-
trait
AppliedTypeTreeApi extends Universe.TypTreeApi
The API that all applied type trees support
The API that all applied type trees support
- Definition Classes
- Trees
-
abstract
class
AppliedTypeTreeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
AppliedTypeTree(tpt, args)
.An extractor class to create and pattern match with syntax
AppliedTypeTree(tpt, args)
. This AST node corresponds to the following Scala code:tpt[args]
Should only be used with
tpt
nodes which are types, i.e. which haveisType
returningtrue
. OtherwiseTypeApply
should be used instead.List[Int] as in
val x: List[Int] = ???
// represented as AppliedTypeTree(Ident(<List>), List(TypeTree(<Int>)))def foo[T] = ??? foo[Int] // represented as TypeApply(Ident(<foo>), List(TypeTree(<Int>)))
- Definition Classes
- Trees
-
abstract
type
Apply >: Null <: Universe.ApplyApi with Universe.GenericApply
Value application
Value application
- Definition Classes
- Trees
-
trait
ApplyApi extends Universe.GenericApplyApi
The API that all applies support
The API that all applies support
- Definition Classes
- Trees
-
abstract
class
ApplyExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Apply(fun, args)
.An extractor class to create and pattern match with syntax
Apply(fun, args)
. This AST node corresponds to the following Scala code:fun(args)
For instance:
fun[targs](args)
Is expressed as:
Apply(TypeApply(fun, targs), args)
- Definition Classes
- Trees
-
abstract
type
Assign >: Null <: Universe.AssignApi with Universe.TermTree
Assignment
Assignment
- Definition Classes
- Trees
-
trait
AssignApi extends Universe.TermTreeApi
The API that all assigns support
The API that all assigns support
- Definition Classes
- Trees
-
abstract
class
AssignExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Assign(lhs, rhs)
.An extractor class to create and pattern match with syntax
Assign(lhs, rhs)
. This AST node corresponds to the following Scala code:lhs = rhs
- Definition Classes
- Trees
-
abstract
type
AssignOrNamedArg >: Null <: Universe.AssignOrNamedArgApi with Universe.TermTree
Either an assignment or a named argument.
Either an assignment or a named argument. Only appears in argument lists, eliminated by compiler phase typecheck (doTypedApply), resurrected by reifier.
- Definition Classes
- Trees
-
trait
AssignOrNamedArgApi extends Universe.TermTreeApi
The API that all assigns support
The API that all assigns support
- Definition Classes
- Trees
-
abstract
class
AssignOrNamedArgExtractor extends AnyRef
An extractor class to create and pattern match with syntax
AssignOrNamedArg(lhs, rhs)
.An extractor class to create and pattern match with syntax
AssignOrNamedArg(lhs, rhs)
. This AST node corresponds to the following Scala code:m.f(lhs = rhs)
@annotation(lhs = rhs)
- Definition Classes
- Trees
-
abstract
type
Bind >: Null <: Universe.BindApi with Universe.DefTree
Bind a variable to a rhs pattern.
Bind a variable to a rhs pattern.
Eliminated by compiler phases patmat (in the new pattern matcher of 2.10) or explicitouter (in the old pre-2.10 pattern matcher).
- Definition Classes
- Trees
-
trait
BindApi extends Universe.DefTreeApi
The API that all binds support
The API that all binds support
- Definition Classes
- Trees
-
abstract
class
BindExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Bind(name, body)
.An extractor class to create and pattern match with syntax
Bind(name, body)
. This AST node corresponds to the following Scala code:pat*
- Definition Classes
- Trees
-
abstract
type
Block >: Null <: Universe.BlockApi with Universe.TermTree
Block of expressions (semicolon separated expressions)
Block of expressions (semicolon separated expressions)
- Definition Classes
- Trees
-
trait
BlockApi extends Universe.TermTreeApi
The API that all blocks support
The API that all blocks support
- Definition Classes
- Trees
-
abstract
class
BlockExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Block(stats, expr)
.An extractor class to create and pattern match with syntax
Block(stats, expr)
. This AST node corresponds to the following Scala code:{ stats; expr }
If the block is empty, the
expr
is set toLiteral(Constant(()))
.- Definition Classes
- Trees
-
abstract
type
CaseDef >: Null <: Universe.CaseDefApi with Universe.Tree
Case clause in a pattern match.
Case clause in a pattern match. (except for occurrences in switch statements). Eliminated by compiler phases patmat (in the new pattern matcher of 2.10) or explicitouter (in the old pre-2.10 pattern matcher)
- Definition Classes
- Trees
-
trait
CaseDefApi extends Universe.TreeApi
The API that all case defs support
The API that all case defs support
- Definition Classes
- Trees
-
abstract
class
CaseDefExtractor extends AnyRef
An extractor class to create and pattern match with syntax
CaseDef(pat, guard, body)
.An extractor class to create and pattern match with syntax
CaseDef(pat, guard, body)
. This AST node corresponds to the following Scala code:case
patif
guard => bodyIf the guard is not present, the
guard
is set toEmptyTree
. If the body is not specified, thebody
is set toLiteral(Constant(()))
- Definition Classes
- Trees
-
abstract
type
ClassDef >: Null <: Universe.ClassDefApi with Universe.ImplDef
A class definition.
A class definition.
- Definition Classes
- Trees
-
trait
ClassDefApi extends Universe.ImplDefApi
The API that all class defs support
The API that all class defs support
- Definition Classes
- Trees
-
abstract
class
ClassDefExtractor extends AnyRef
An extractor class to create and pattern match with syntax
ClassDef(mods, name, tparams, impl)
.An extractor class to create and pattern match with syntax
ClassDef(mods, name, tparams, impl)
. This AST node corresponds to the following Scala code:mods
class
name [tparams] implWhere impl stands for:
extends
parents { defs }- Definition Classes
- Trees
-
abstract
type
CompoundTypeTree >: Null <: Universe.CompoundTypeTreeApi with Universe.TypTree
Intersection type <parent1> with ...
Intersection type <parent1> with ... with <parentN> { <decls> }, eliminated by RefCheck
- Definition Classes
- Trees
-
trait
CompoundTypeTreeApi extends Universe.TypTreeApi
The API that all compound type trees support
The API that all compound type trees support
- Definition Classes
- Trees
-
abstract
class
CompoundTypeTreeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
CompoundTypeTree(templ)
.An extractor class to create and pattern match with syntax
CompoundTypeTree(templ)
. This AST node corresponds to the following Scala code:parent1 with ... with parentN { refinement }
- Definition Classes
- Trees
-
abstract
type
DefDef >: Null <: Universe.DefDefApi with Universe.ValOrDefDef
A method or macro definition.
A method or macro definition.
- Definition Classes
- Trees
-
trait
DefDefApi extends Universe.ValOrDefDefApi
The API that all def defs support
The API that all def defs support
- Definition Classes
- Trees
-
abstract
class
DefDefExtractor extends AnyRef
An extractor class to create and pattern match with syntax
DefDef(mods, name, tparams, vparamss, tpt, rhs)
.An extractor class to create and pattern match with syntax
DefDef(mods, name, tparams, vparamss, tpt, rhs)
. This AST node corresponds to the following Scala code:mods
def
name[tparams](vparams_1)...(vparams_n): tpt = rhsIf the return type is not specified explicitly (i.e. is meant to be inferred), this is expressed by having
tpt
set toTypeTree()
(but not to anEmptyTree
!).- Definition Classes
- Trees
-
abstract
type
DefTree >: Null <: Universe.DefTreeApi with Universe.SymTree with Universe.NameTree
A tree representing a symbol-defining entity: 1) A declaration or a definition (type, class, object, package, val, var, or def) 2)
Bind
that is used to represent binding occurrences in pattern matches 3)LabelDef
that is used internally to represent while loopsA tree representing a symbol-defining entity: 1) A declaration or a definition (type, class, object, package, val, var, or def) 2)
Bind
that is used to represent binding occurrences in pattern matches 3)LabelDef
that is used internally to represent while loops- Definition Classes
- Trees
-
trait
DefTreeApi extends Universe.SymTreeApi with Universe.NameTreeApi
The API that all def trees support
The API that all def trees support
- Definition Classes
- Trees
-
abstract
type
ExistentialTypeTree >: Null <: Universe.ExistentialTypeTreeApi with Universe.TypTree
Existential type tree node
Existential type tree node
- Definition Classes
- Trees
-
trait
ExistentialTypeTreeApi extends Universe.TypTreeApi
The API that all existential type trees support
The API that all existential type trees support
- Definition Classes
- Trees
-
abstract
class
ExistentialTypeTreeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
ExistentialTypeTree(tpt, whereClauses)
.An extractor class to create and pattern match with syntax
ExistentialTypeTree(tpt, whereClauses)
. This AST node corresponds to the following Scala code:tpt forSome { whereClauses }
- Definition Classes
- Trees
-
abstract
type
Function >: Null <: Universe.FunctionApi with Universe.TermTree with Universe.SymTree
Anonymous function, eliminated by compiler phase lambdalift
Anonymous function, eliminated by compiler phase lambdalift
- Definition Classes
- Trees
-
trait
FunctionApi extends Universe.TermTreeApi with Universe.SymTreeApi
The API that all functions support
The API that all functions support
- Definition Classes
- Trees
-
abstract
class
FunctionExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Function(vparams, body)
.An extractor class to create and pattern match with syntax
Function(vparams, body)
. This AST node corresponds to the following Scala code:vparams => body
The symbol of a Function is a synthetic TermSymbol. It is the owner of the function's parameters.
- Definition Classes
- Trees
-
abstract
type
GenericApply >: Null <: Universe.GenericApplyApi with Universe.TermTree
Common base class for Apply and TypeApply.
Common base class for Apply and TypeApply.
- Definition Classes
- Trees
-
trait
GenericApplyApi extends Universe.TermTreeApi
The API that all applies support
The API that all applies support
- Definition Classes
- Trees
-
abstract
type
Ident >: Null <: Universe.IdentApi with Universe.RefTree
A reference to identifier
name
.A reference to identifier
name
.- Definition Classes
- Trees
-
trait
IdentApi extends Universe.RefTreeApi
The API that all idents support
The API that all idents support
- Definition Classes
- Trees
-
abstract
class
IdentExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Ident(qual, name)
.An extractor class to create and pattern match with syntax
Ident(qual, name)
. This AST node corresponds to the following Scala code:name
Type checker converts idents that refer to enclosing fields or methods to selects. For example, name ==> this.name
- Definition Classes
- Trees
-
abstract
type
If >: Null <: Universe.IfApi with Universe.TermTree
Conditional expression
Conditional expression
- Definition Classes
- Trees
-
trait
IfApi extends Universe.TermTreeApi
The API that all ifs support
The API that all ifs support
- Definition Classes
- Trees
-
abstract
class
IfExtractor extends AnyRef
An extractor class to create and pattern match with syntax
If(cond, thenp, elsep)
.An extractor class to create and pattern match with syntax
If(cond, thenp, elsep)
. This AST node corresponds to the following Scala code:if
(cond) thenpelse
elsepIf the alternative is not present, the
elsep
is set toLiteral(Constant(()))
.- Definition Classes
- Trees
-
abstract
type
ImplDef >: Null <: Universe.ImplDefApi with Universe.MemberDef
A common base class for class and object definitions.
A common base class for class and object definitions.
- Definition Classes
- Trees
-
trait
ImplDefApi extends Universe.MemberDefApi
The API that all impl defs support
The API that all impl defs support
- Definition Classes
- Trees
-
abstract
type
Import >: Null <: Universe.ImportApi with Universe.SymTree
Import clause
Import clause
- Definition Classes
- Trees
-
trait
ImportApi extends Universe.SymTreeApi
The API that all imports support
The API that all imports support
- Definition Classes
- Trees
-
abstract
class
ImportExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Import(expr, selectors)
.An extractor class to create and pattern match with syntax
Import(expr, selectors)
. This AST node corresponds to the following Scala code:import expr.{selectors}
Selectors are a list of ImportSelectors, which conceptually are pairs of names (from, to). The last (and maybe only name) may be a nme.WILDCARD. For instance:
import qual.{x, y => z, _}
Would be represented as:
Import(qual, List(("x", "x"), ("y", "z"), (WILDCARD, null)))
The symbol of an
Import
is an import symbol @see Symbol.newImport. It's used primarily as a marker to check that the import has been typechecked.- Definition Classes
- Trees
-
abstract
type
ImportSelector >: Null <: Universe.ImportSelectorApi
Import selector (not a tree, but a component of the
Import
tree)Import selector (not a tree, but a component of the
Import
tree)Representation of an imported name its optional rename and their optional positions
Eliminated by typecheck.
- Definition Classes
- Trees
-
trait
ImportSelectorApi extends AnyRef
The API that all import selectors support
The API that all import selectors support
- Definition Classes
- Trees
-
abstract
class
ImportSelectorExtractor extends AnyRef
An extractor class to create and pattern match with syntax
ImportSelector(name:, namePos, rename, renamePos)
.An extractor class to create and pattern match with syntax
ImportSelector(name:, namePos, rename, renamePos)
. This is not an AST node, it is used as a part of theImport
node.- Definition Classes
- Trees
-
abstract
type
LabelDef >: Null <: Universe.LabelDefApi with Universe.DefTree with Universe.TermTree
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.
- Definition Classes
- Trees
-
trait
LabelDefApi extends Universe.DefTreeApi with Universe.TermTreeApi
The API that all label defs support
The API that all label defs support
- Definition Classes
- Trees
-
abstract
class
LabelDefExtractor extends AnyRef
An extractor class to create and pattern match with syntax
LabelDef(name, params, rhs)
.An extractor class to create and pattern match with syntax
LabelDef(name, params, rhs)
.This AST node does not have direct correspondence to Scala code. It is used for tailcalls and like. For example, while/do are desugared to label defs as follows:
while (cond) body ==> LabelDef($L, List(), if (cond) { body; L$() } else ())
do body while (cond) ==> LabelDef($L, List(), body; if (cond) L$() else ())
- Definition Classes
- Trees
-
abstract
type
Literal >: Null <: Universe.LiteralApi with Universe.TermTree
Literal
Literal
- Definition Classes
- Trees
-
trait
LiteralApi extends Universe.TermTreeApi
The API that all literals support
The API that all literals support
- Definition Classes
- Trees
-
abstract
class
LiteralExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Literal(value)
.An extractor class to create and pattern match with syntax
Literal(value)
. This AST node corresponds to the following Scala code:value
- Definition Classes
- Trees
-
abstract
type
Match >: Null <: Universe.MatchApi with Universe.TermTree
- Pattern matching expression (before compiler phase explicitouter before 2.10 / patmat from 2.10)
- Pattern matching expression (before compiler phase explicitouter before 2.10 / patmat from 2.10)
- Switch statements (after compiler phase explicitouter before 2.10 / patmat from 2.10)
After compiler phase explicitouter before 2.10 / patmat from 2.10, cases will satisfy the following constraints:
- all guards are
EmptyTree
, - all patterns will be either
Literal(Constant(x:Int))
orAlternative(lit|...|lit)
- except for an "otherwise" branch, which has pattern
Ident(nme.WILDCARD)
- Definition Classes
- Trees
-
trait
MatchApi extends Universe.TermTreeApi
The API that all matches support
The API that all matches support
- Definition Classes
- Trees
-
abstract
class
MatchExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Match(selector, cases)
.An extractor class to create and pattern match with syntax
Match(selector, cases)
. This AST node corresponds to the following Scala code:selector
match
{ cases }Match
is also used in pattern matching assignments likeval (foo, bar) = baz
.- Definition Classes
- Trees
-
abstract
type
MemberDef >: Null <: Universe.MemberDefApi with Universe.DefTree
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.
- Definition Classes
- Trees
-
trait
MemberDefApi extends Universe.DefTreeApi
The API that all member defs support
The API that all member defs support
- Definition Classes
- Trees
-
abstract
class
ModifiersApi extends AnyRef
The API that all Modifiers support
The API that all Modifiers support
- Definition Classes
- Trees
-
abstract
class
ModifiersExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Modifiers(flags, privateWithin, annotations)
.An extractor class to create and pattern match with syntax
Modifiers(flags, privateWithin, annotations)
. Modifiers encapsulate flags, visibility annotations and Scala annotations for member definitions.- Definition Classes
- Trees
-
abstract
type
ModuleDef >: Null <: Universe.ModuleDefApi with Universe.ImplDef
An object definition, e.g.
An object definition, e.g.
object Foo
. Internally, objects are quite frequently called modules to reduce ambiguity. Eliminated by compiler phase refcheck.- Definition Classes
- Trees
-
trait
ModuleDefApi extends Universe.ImplDefApi
The API that all module defs support
The API that all module defs support
- Definition Classes
- Trees
-
abstract
class
ModuleDefExtractor extends AnyRef
An extractor class to create and pattern match with syntax
ModuleDef(mods, name, impl)
.An extractor class to create and pattern match with syntax
ModuleDef(mods, name, impl)
. This AST node corresponds to the following Scala code:mods
object
name implWhere impl stands for:
extends
parents { defs }- Definition Classes
- Trees
-
abstract
type
NameTree >: Null <: Universe.NameTreeApi with Universe.Tree
A tree that carries a name, e.g.
A tree that carries a name, e.g. by defining it (
DefTree
) or by referring to it (RefTree
).- Definition Classes
- Trees
-
trait
NameTreeApi extends Universe.TreeApi
The API that all name trees support
The API that all name trees support
- Definition Classes
- Trees
-
abstract
type
New >: Null <: Universe.NewApi with Universe.TermTree
Object instantiation
Object instantiation
- Definition Classes
- Trees
-
trait
NewApi extends Universe.TermTreeApi
The API that all news support
The API that all news support
- Definition Classes
- Trees
-
abstract
class
NewExtractor extends AnyRef
An extractor class to create and pattern match with syntax
New(tpt)
.An extractor class to create and pattern match with syntax
New(tpt)
. This AST node corresponds to the following Scala code:new
TThis node always occurs in the following context:
(
new
tpt).<init>[targs](args)For example, an AST representation of:
new Example[Int](2)(3)
is the following code:
Apply( Apply( TypeApply( Select(New(TypeTree(typeOf[Example])), nme.CONSTRUCTOR) TypeTree(typeOf[Int])), List(Literal(Constant(2)))), List(Literal(Constant(3))))
- Definition Classes
- Trees
-
abstract
type
PackageDef >: Null <: Universe.PackageDefApi with Universe.MemberDef
A packaging, such as
package pid { stats }
A packaging, such as
package pid { stats }
- Definition Classes
- Trees
-
trait
PackageDefApi extends Universe.MemberDefApi
The API that all package defs support
The API that all package defs support
- Definition Classes
- Trees
-
abstract
class
PackageDefExtractor extends AnyRef
An extractor class to create and pattern match with syntax
PackageDef(pid, stats)
.An extractor class to create and pattern match with syntax
PackageDef(pid, stats)
. This AST node corresponds to the following Scala code:package
pid { stats }- Definition Classes
- Trees
-
abstract
type
RefTree >: Null <: Universe.RefTreeApi with Universe.SymTree with Universe.NameTree
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.
- Definition Classes
- Trees
-
trait
RefTreeApi extends Universe.SymTreeApi with Universe.NameTreeApi
The API that all ref trees support
The API that all ref trees support
- Definition Classes
- Trees
-
abstract
class
RefTreeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
RefTree(qual, name)
.An extractor class to create and pattern match with syntax
RefTree(qual, name)
. This AST node corresponds to either Ident, Select or SelectFromTypeTree.- Definition Classes
- Trees
-
abstract
type
Return >: Null <: Universe.ReturnApi with Universe.SymTree with Universe.TermTree
Return expression
Return expression
- Definition Classes
- Trees
-
trait
ReturnApi extends Universe.TermTreeApi
The API that all returns support
The API that all returns support
- Definition Classes
- Trees
-
abstract
class
ReturnExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Return(expr)
.An extractor class to create and pattern match with syntax
Return(expr)
. This AST node corresponds to the following Scala code:return
exprThe symbol of a Return node is the enclosing method.
- Definition Classes
- Trees
-
abstract
type
Select >: Null <: Universe.SelectApi with Universe.RefTree
A member selection <qualifier> .
A member selection <qualifier> . <name>
- Definition Classes
- Trees
-
trait
SelectApi extends Universe.RefTreeApi
The API that all selects support
The API that all selects support
- Definition Classes
- Trees
-
abstract
class
SelectExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Select(qual, name)
.An extractor class to create and pattern match with syntax
Select(qual, name)
. This AST node corresponds to the following Scala code:qualifier.selector
Should only be used with
qualifier
nodes which are terms, i.e. which haveisTerm
returningtrue
. OtherwiseSelectFromTypeTree
should be used instead.foo.Bar // represented as Select(Ident(<foo>), <Bar>) Foo#Bar // represented as SelectFromTypeTree(Ident(<Foo>), <Bar>)
- Definition Classes
- Trees
-
abstract
type
SelectFromTypeTree >: Null <: Universe.SelectFromTypeTreeApi with Universe.TypTree with Universe.RefTree
Type selection <qualifier> # <name>, eliminated by RefCheck
Type selection <qualifier> # <name>, eliminated by RefCheck
- Definition Classes
- Trees
-
trait
SelectFromTypeTreeApi extends Universe.TypTreeApi with Universe.RefTreeApi
The API that all selects from type trees support
The API that all selects from type trees support
- Definition Classes
- Trees
-
abstract
class
SelectFromTypeTreeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
SelectFromTypeTree(qualifier, name)
.An extractor class to create and pattern match with syntax
SelectFromTypeTree(qualifier, name)
. This AST node corresponds to the following Scala code:qualifier # selector
Note: a path-dependent type p.T is expressed as p.type # T
Should only be used with
qualifier
nodes which are types, i.e. which haveisType
returningtrue
. OtherwiseSelect
should be used instead.Foo#Bar // represented as SelectFromTypeTree(Ident(<Foo>), <Bar>) foo.Bar // represented as Select(Ident(<foo>), <Bar>)
- Definition Classes
- Trees
-
abstract
type
SingletonTypeTree >: Null <: Universe.SingletonTypeTreeApi with Universe.TypTree
Singleton type, eliminated by RefCheck
Singleton type, eliminated by RefCheck
- Definition Classes
- Trees
-
trait
SingletonTypeTreeApi extends Universe.TypTreeApi
The API that all singleton type trees support
The API that all singleton type trees support
- Definition Classes
- Trees
-
abstract
class
SingletonTypeTreeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
SingletonTypeTree(ref)
.An extractor class to create and pattern match with syntax
SingletonTypeTree(ref)
. This AST node corresponds to the following Scala code:ref.type
- Definition Classes
- Trees
-
abstract
type
Star >: Null <: Universe.StarApi with Universe.TermTree
Repetition of pattern.
Repetition of pattern.
Eliminated by compiler phases patmat (in the new pattern matcher of 2.10) or explicitouter (in the old pre-2.10 pattern matcher).
- Definition Classes
- Trees
-
trait
StarApi extends Universe.TermTreeApi
The API that all stars support
The API that all stars support
- Definition Classes
- Trees
-
abstract
class
StarExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Star(elem)
.An extractor class to create and pattern match with syntax
Star(elem)
. This AST node corresponds to the following Scala code:pat*
- Definition Classes
- Trees
-
abstract
type
Super >: Null <: Universe.SuperApi with Universe.TermTree
Super reference, where
qual
is the correspondingthis
reference.Super reference, where
qual
is the correspondingthis
reference. A super referenceC.super[M]
is represented asSuper(This(C), M)
.- Definition Classes
- Trees
-
trait
SuperApi extends Universe.TermTreeApi
The API that all supers support
The API that all supers support
- Definition Classes
- Trees
-
abstract
class
SuperExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Super(qual, mix)
.An extractor class to create and pattern match with syntax
Super(qual, mix)
. This AST node corresponds to the following Scala code:C.super[M]
Which is represented as:
Super(This(C), M)
If
mix
is empty, it is tpnme.EMPTY.The symbol of a Super is the class _from_ which the super reference is made. For instance in C.super(...), it would be C.
- Definition Classes
- Trees
-
abstract
type
SymTree >: Null <: Universe.SymTreeApi with Universe.Tree
A tree that carries a symbol, e.g.
A tree that carries a symbol, e.g. by defining it (
DefTree
) or by referring to it (RefTree
). Such trees start their life naked, returningNoSymbol
, but after being typechecked without errors they hold non-empty symbols.- Definition Classes
- Trees
-
trait
SymTreeApi extends Universe.TreeApi
The API that all sym trees support
The API that all sym trees support
- Definition Classes
- Trees
-
abstract
type
Template >: Null <: Universe.TemplateApi with Universe.SymTree
Instantiation template of a class or trait
Instantiation template of a class or trait
- Definition Classes
- Trees
-
trait
TemplateApi extends Universe.SymTreeApi
The API that all templates support
The API that all templates support
- Definition Classes
- Trees
-
abstract
class
TemplateExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Template(parents, self, body)
.An extractor class to create and pattern match with syntax
Template(parents, self, body)
. This AST node corresponds to the following Scala code:extends
parents { self => body }In case when the self-type annotation is missing, it is represented as an empty value definition with nme.WILDCARD as name and NoType as type.
The symbol of a template is a local dummy. @see Symbol.newLocalDummy The owner of the local dummy is the enclosing trait or class. The local dummy is itself the owner of any local blocks. For example:
class C { def foo { // owner is C def bar // owner is local dummy } }
- Definition Classes
- Trees
-
abstract
type
TermTree >: Null <: Universe.TermTreeApi with Universe.Tree
A tree for a term.
A tree for a term. Not all trees representing terms are TermTrees; use isTerm to reliably identify terms.
- Definition Classes
- Trees
-
trait
TermTreeApi extends Universe.TreeApi
The API that all term trees support
The API that all term trees support
- Definition Classes
- Trees
-
abstract
type
This >: Null <: Universe.ThisApi with Universe.TermTree with Universe.SymTree
Self reference
Self reference
- Definition Classes
- Trees
-
trait
ThisApi extends Universe.TermTreeApi with Universe.SymTreeApi
The API that all thises support
The API that all thises support
- Definition Classes
- Trees
-
abstract
class
ThisExtractor extends AnyRef
An extractor class to create and pattern match with syntax
This(qual)
.An extractor class to create and pattern match with syntax
This(qual)
. This AST node corresponds to the following Scala code:qual.this
The symbol of a This is the class to which the this refers. For instance in C.this, it would be C.
- Definition Classes
- Trees
-
abstract
type
Throw >: Null <: Universe.ThrowApi with Universe.TermTree
Throw expression
Throw expression
- Definition Classes
- Trees
-
trait
ThrowApi extends Universe.TermTreeApi
The API that all tries support
The API that all tries support
- Definition Classes
- Trees
-
abstract
class
ThrowExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Throw(expr)
.An extractor class to create and pattern match with syntax
Throw(expr)
. This AST node corresponds to the following Scala code:throw
expr- Definition Classes
- Trees
-
abstract
class
Transformer extends AnyRef
A class that implement a default tree transformation strategy: breadth-first component-wise cloning.
A class that implement a default tree transformation strategy: breadth-first component-wise cloning.
- Definition Classes
- Trees
-
class
Traverser extends AnyRef
A class that implement a default tree traversal strategy: breadth-first component-wise.
A class that implement a default tree traversal strategy: breadth-first component-wise.
- Definition Classes
- Trees
-
abstract
type
Tree >: Null <: Universe.TreeApi
The type of Scala abstract syntax trees.
The type of Scala abstract syntax trees.
- Definition Classes
- Trees
-
trait
TreeApi extends Product
The API that all trees support.
The API that all trees support. The main source of information about trees is the scala.reflect.api.Trees page.
- Definition Classes
- Trees
-
abstract
type
TreeCopier >: Null <: Universe.TreeCopierOps
The type of standard (lazy) tree copiers.
The type of standard (lazy) tree copiers.
- Definition Classes
- Trees
-
abstract
class
TreeCopierOps extends AnyRef
The API of a tree copier.
The API of a tree copier.
- Definition Classes
- Trees
-
abstract
type
Try >: Null <: Universe.TryApi with Universe.TermTree
Try catch node
Try catch node
- Definition Classes
- Trees
-
trait
TryApi extends Universe.TermTreeApi
The API that all tries support
The API that all tries support
- Definition Classes
- Trees
-
abstract
class
TryExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Try(block, catches, finalizer)
.An extractor class to create and pattern match with syntax
Try(block, catches, finalizer)
. This AST node corresponds to the following Scala code:try
blockcatch
{ catches }finally
finalizerIf the finalizer is not present, the
finalizer
is set toEmptyTree
.- Definition Classes
- Trees
-
abstract
type
TypTree >: Null <: Universe.TypTreeApi with Universe.Tree
A tree for a type.
A tree for a type. Not all trees representing types are TypTrees; use isType to reliably identify types.
- Definition Classes
- Trees
-
trait
TypTreeApi extends Universe.TreeApi
The API that all typ trees support
The API that all typ trees support
- Definition Classes
- Trees
-
abstract
type
TypeApply >: Null <: Universe.TypeApplyApi with Universe.GenericApply
Explicit type application.
Explicit type application.
- Definition Classes
- Trees
-
trait
TypeApplyApi extends Universe.GenericApplyApi
The API that all type applies support
The API that all type applies support
- Definition Classes
- Trees
-
abstract
class
TypeApplyExtractor extends AnyRef
An extractor class to create and pattern match with syntax
TypeApply(fun, args)
.An extractor class to create and pattern match with syntax
TypeApply(fun, args)
. This AST node corresponds to the following Scala code:fun[args]
Should only be used with
fun
nodes which are terms, i.e. which haveisTerm
returningtrue
. OtherwiseAppliedTypeTree
should be used instead.def foo[T] = ??? foo[Int] // represented as TypeApply(Ident(<foo>), List(TypeTree(<Int>)))
List[Int] as in
val x: List[Int] = ???
// represented as AppliedTypeTree(Ident(<List>), List(TypeTree(<Int>)))- Definition Classes
- Trees
-
abstract
type
TypeBoundsTree >: Null <: Universe.TypeBoundsTreeApi with Universe.TypTree
Type bounds tree node
Type bounds tree node
- Definition Classes
- Trees
-
trait
TypeBoundsTreeApi extends Universe.TypTreeApi
The API that all type bound trees support
The API that all type bound trees support
- Definition Classes
- Trees
-
abstract
class
TypeBoundsTreeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
TypeBoundsTree(lo, hi)
.An extractor class to create and pattern match with syntax
TypeBoundsTree(lo, hi)
. This AST node corresponds to the following Scala code:>: lo <: hi
- Definition Classes
- Trees
-
abstract
type
TypeDef >: Null <: Universe.TypeDefApi with Universe.MemberDef
An abstract type, a type parameter, or a type alias.
An abstract type, a type parameter, or a type alias. Eliminated by erasure.
- Definition Classes
- Trees
-
trait
TypeDefApi extends Universe.MemberDefApi
The API that all type defs support
The API that all type defs support
- Definition Classes
- Trees
-
abstract
class
TypeDefExtractor extends AnyRef
An extractor class to create and pattern match with syntax
TypeDef(mods, name, tparams, rhs)
.An extractor class to create and pattern match with syntax
TypeDef(mods, name, tparams, rhs)
. This AST node corresponds to the following Scala code:mods
type
name[tparams] = rhsmods
type
name[tparams] >: lo <: hiFirst usage illustrates
TypeDefs
representing type aliases and type parameters. Second usage illustratesTypeDefs
representing abstract types, where lo and hi are bothTypeBoundsTrees
andModifier.deferred
is set in mods.- Definition Classes
- Trees
-
abstract
type
TypeTree >: Null <: Universe.TypeTreeApi with Universe.TypTree
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.- Definition Classes
- Trees
-
trait
TypeTreeApi extends Universe.TypTreeApi
The API that all type trees support
The API that all type trees support
- Definition Classes
- Trees
-
abstract
class
TypeTreeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
TypeTree()
.An extractor class to create and pattern match with syntax
TypeTree()
. This AST node does not have direct correspondence to Scala code, and is emitted by everywhere when we want to wrap aType
in aTree
.- Definition Classes
- Trees
-
abstract
type
Typed >: Null <: Universe.TypedApi with Universe.TermTree
Type annotation, eliminated by compiler phase cleanup
Type annotation, eliminated by compiler phase cleanup
- Definition Classes
- Trees
-
trait
TypedApi extends Universe.TermTreeApi
The API that all typeds support
The API that all typeds support
- Definition Classes
- Trees
-
abstract
class
TypedExtractor extends AnyRef
An extractor class to create and pattern match with syntax
Typed(expr, tpt)
.An extractor class to create and pattern match with syntax
Typed(expr, tpt)
. This AST node corresponds to the following Scala code:expr: tpt
- Definition Classes
- Trees
-
abstract
type
UnApply >: Null <: Universe.UnApplyApi with Universe.TermTree
Used to represent
unapply
methods in pattern matching.Used to represent
unapply
methods in pattern matching.For example:
2 match { case Foo(x) => x }
Is represented as:
Match( Literal(Constant(2)), List( CaseDef( UnApply( // a dummy node that carries the type of unapplication to patmat // the
here doesn't have an underlying symbol // it only has a type assigned, therefore after `untypecheck` this tree is no longer typeable Apply(Select(Ident(Foo), TermName("unapply")), List(Ident(TermName("" )))), // arguments of the unapply => nothing synthetic here List(Bind(TermName("x"), Ident(nme.WILDCARD)))), EmptyTree, Ident(TermName("x")))))Introduced by typer. Eliminated by compiler phases patmat (in the new pattern matcher of 2.10) or explicitouter (in the old pre-2.10 pattern matcher).
- Definition Classes
- Trees
-
trait
UnApplyApi extends Universe.TermTreeApi
The API that all unapplies support
The API that all unapplies support
- Definition Classes
- Trees
-
abstract
class
UnApplyExtractor extends AnyRef
An extractor class to create and pattern match with syntax
UnApply(fun, args)
.An extractor class to create and pattern match with syntax
UnApply(fun, args)
. This AST node does not have direct correspondence to Scala code, and is introduced when typechecking pattern matches andtry
blocks.- Definition Classes
- Trees
-
abstract
type
ValDef >: Null <: Universe.ValDefApi with Universe.ValOrDefDef
Broadly speaking, a value definition.
Broadly speaking, a value definition. All these are encoded as ValDefs:
- immutable values, e.g. "val x"
- mutable values, e.g. "var x" - the MUTABLE flag set in mods
- lazy values, e.g. "lazy val x" - the LAZY flag set in mods
- method parameters, see vparamss in scala.reflect.api.Trees#DefDef - the PARAM flag is set in mods
- explicit self-types, e.g. class A { self: Bar => }
- Definition Classes
- Trees
-
trait
ValDefApi extends Universe.ValOrDefDefApi
The API that all val defs support
The API that all val defs support
- Definition Classes
- Trees
-
abstract
class
ValDefExtractor extends AnyRef
An extractor class to create and pattern match with syntax
ValDef(mods, name, tpt, rhs)
.An extractor class to create and pattern match with syntax
ValDef(mods, name, tpt, rhs)
. This AST node corresponds to any of the following Scala code:mods
val
name: tpt = rhsmods
var
name: tpt = rhsmods name: tpt = rhs // in signatures of function and method definitions
self: Bar => // self-types
If the type of a value is not specified explicitly (i.e. is meant to be inferred), this is expressed by having
tpt
set toTypeTree()
(but not to anEmptyTree
!).- Definition Classes
- Trees
-
abstract
type
ValOrDefDef >: Null <: Universe.ValOrDefDefApi with Universe.MemberDef
A common base class for ValDefs and DefDefs.
A common base class for ValDefs and DefDefs.
- Definition Classes
- Trees
-
trait
ValOrDefDefApi extends Universe.MemberDefApi
The API that all val defs and def defs support
The API that all val defs and def defs support
- Definition Classes
- Trees
-
trait
TypeTag[T] extends Universe.WeakTypeTag[T] with Equals with Serializable
A
TypeTag
is a scala.reflect.api.TypeTags#WeakTypeTag with the additional static guarantee that all type references are concrete, i.e.A
TypeTag
is a scala.reflect.api.TypeTags#WeakTypeTag with the additional static guarantee that all type references are concrete, i.e. it does not contain any references to unresolved type parameters or abstract types.- Definition Classes
- TypeTags
- Annotations
- @implicitNotFound( "No TypeTag available for ${T}" )
- See also
-
trait
WeakTypeTag[T] extends Equals with Serializable
If an implicit value of type
WeakTypeTag[T]
is required, the compiler will create one, and the reflective representation ofT
can be accessed via thetpe
field.If an implicit value of type
WeakTypeTag[T]
is required, the compiler will create one, and the reflective representation ofT
can be accessed via thetpe
field. Components ofT
can be references to type parameters or abstract types. Note thatWeakTypeTag
makes an effort to be as concrete as possible, i.e. ifTypeTag
s are available for the referenced type arguments or abstract types, they are used to embed the concrete types into the WeakTypeTag. Otherwise the WeakTypeTag will contain a reference to an abstract type. This behavior can be useful, when one expectsT
to be perhaps be partially abstract, but requires special care to handle this case. However, ifT
is expected to be fully known, use scala.reflect.api.TypeTags#TypeTag instead, which statically guarantees this property.For more information about
TypeTag
s, see the Reflection Guide: TypeTags- Definition Classes
- TypeTags
- Annotations
- @implicitNotFound( "No WeakTypeTag available for ${T}" )
- See also
-
abstract
type
AnnotatedType >: Null <: Universe.AnnotatedTypeApi with Universe.Type
The
AnnotatedType
type signature is used for annotated types of the for<type> @<annotation>
.The
AnnotatedType
type signature is used for annotated types of the for<type> @<annotation>
.- Definition Classes
- Types
-
trait
AnnotatedTypeApi extends Universe.TypeApi
The API that all annotated types support.
The API that all annotated types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
AnnotatedTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
AnnotatedType(annotations, underlying)
.An extractor class to create and pattern match with syntax
AnnotatedType(annotations, underlying)
. Here,annotations
are the annotations decorating the underlying typeunderlying
.selfSym
is a symbol representing the annotated type itself.- Definition Classes
- Types
-
abstract
type
BoundedWildcardType >: Null <: Universe.BoundedWildcardTypeApi with Universe.Type
BoundedWildcardTypes, used only during type inference, are created in two places:
BoundedWildcardTypes, used only during type inference, are created in two places:
- If the expected type of an expression is an existential type, its hidden symbols are replaced with bounded wildcards. 2. When an implicit conversion is being sought based in part on the name of a method in the converted type, a HasMethodMatching type is created: a MethodType with parameters typed as BoundedWildcardTypes.
- Definition Classes
- Types
-
trait
BoundedWildcardTypeApi extends Universe.TypeApi
The API that all this types support.
The API that all this types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
BoundedWildcardTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
BoundedWildcardTypeExtractor(bounds)
withbounds
denoting the type bounds.An extractor class to create and pattern match with syntax
BoundedWildcardTypeExtractor(bounds)
withbounds
denoting the type bounds.- Definition Classes
- Types
-
abstract
type
ClassInfoType >: Null <: Universe.ClassInfoTypeApi with Universe.CompoundType
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 thisC 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)
- Definition Classes
- Types
-
trait
ClassInfoTypeApi extends Universe.TypeApi
The API that all class info types support.
The API that all class info types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
ClassInfoTypeExtractor extends AnyRef
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, andclazz
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, andclazz
is the symbol of the class itself.- Definition Classes
- Types
-
abstract
type
CompoundType >: Null <: Universe.CompoundTypeApi with Universe.Type
A subtype of Type representing refined types as well as
ClassInfo
signatures.A subtype of Type representing refined types as well as
ClassInfo
signatures.- Definition Classes
- Types
-
trait
CompoundTypeApi extends AnyRef
Has no special methods.
Has no special methods. Is here to provides erased identity for
CompoundType
.- Definition Classes
- Types
-
abstract
type
ConstantType >: Null <: Universe.ConstantTypeApi with Universe.SingletonType
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 likeInt(11)
. Here are some constants with their types:1 ConstantType(Constant(1)) "abc" ConstantType(Constant("abc"))
- Definition Classes
- Types
-
trait
ConstantTypeApi extends Universe.TypeApi
The API that all constant types support.
The API that all constant types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
ConstantTypeExtractor extends AnyRef
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.- Definition Classes
- Types
-
abstract
type
ExistentialType >: Null <: Universe.ExistentialTypeApi with Universe.Type
The
ExistentialType
type signature is used for existential types and wildcard types.The
ExistentialType
type signature is used for existential types and wildcard types.- Definition Classes
- Types
-
trait
ExistentialTypeApi extends Universe.TypeApi
The API that all existential types support.
The API that all existential types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
ExistentialTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
ExistentialType(quantified, underlying)
.An extractor class to create and pattern match with syntax
ExistentialType(quantified, underlying)
. Here,quantified
are the type variables bound by the existential type andunderlying
is the type that's existentially quantified.- Definition Classes
- Types
-
abstract
type
MethodType >: Null <: Universe.MethodTypeApi with Universe.Type
The
MethodType
type signature is used to indicate parameters and result type of a methodThe
MethodType
type signature is used to indicate parameters and result type of a method- Definition Classes
- Types
-
trait
MethodTypeApi extends Universe.TypeApi
The API that all method types support.
The API that all method types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
MethodTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
MethodType(params, restpe)
Here,params
is a potentially empty list of parameter symbols of the method, andrestpe
is the result type of the method.An extractor class to create and pattern match with syntax
MethodType(params, restpe)
Here,params
is a potentially empty list of parameter symbols of the method, andrestpe
is the result type of the method. If the method is curried,restpe
would be anotherMethodType
. 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
.- Definition Classes
- Types
-
abstract
type
NullaryMethodType >: Null <: Universe.NullaryMethodTypeApi with Universe.Type
The
NullaryMethodType
type signature is used for parameterless methods with declarations of the formdef foo: T
The
NullaryMethodType
type signature is used for parameterless methods with declarations of the formdef foo: T
- Definition Classes
- Types
-
trait
NullaryMethodTypeApi extends Universe.TypeApi
The API that all nullary method types support.
The API that all nullary method types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
NullaryMethodTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
NullaryMethodType(resultType)
.An extractor class to create and pattern match with syntax
NullaryMethodType(resultType)
. Here,resultType
is the result type of the parameterless method.- Definition Classes
- Types
-
abstract
type
PolyType >: Null <: Universe.PolyTypeApi with Universe.Type
The
PolyType
type signature is used for polymorphic methods that have at least one type parameter.The
PolyType
type signature is used for polymorphic methods that have at least one type parameter.- Definition Classes
- Types
-
trait
PolyTypeApi extends Universe.TypeApi
The API that all polymorphic types support.
The API that all polymorphic types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
PolyTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
PolyType(typeParams, resultType)
.An extractor class to create and pattern match with syntax
PolyType(typeParams, resultType)
. Here,typeParams
are the type parameters of the method andresultType
is the type signature following the type parameters.- Definition Classes
- Types
-
abstract
type
RefinedType >: Null <: Universe.RefinedTypeApi with Universe.CompoundType
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))
- Definition Classes
- Types
-
trait
RefinedTypeApi extends Universe.TypeApi
The API that all refined types support.
The API that all refined types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
RefinedTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
RefinedType(parents, decls)
Here,parents
is the list of parent types of the class, anddecls
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, anddecls
is the scope containing all declarations in the class.- Definition Classes
- Types
-
abstract
type
SingleType >: Null <: Universe.SingleTypeApi with Universe.SingletonType
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)
- Definition Classes
- Types
-
trait
SingleTypeApi extends Universe.TypeApi
The API that all single types support.
The API that all single types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
SingleTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
SingleType(pre, sym)
Here,pre
is the prefix of the single-type, andsym
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, andsym
is the stable value symbol referred to by the single-type.- Definition Classes
- Types
-
abstract
type
SingletonType >: Null <: Universe.SingletonTypeApi with Universe.Type
The type of Scala singleton types, i.e., types that are inhabited by only one nun-null value.
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.
- Definition Classes
- Types
-
trait
SingletonTypeApi extends AnyRef
Has no special methods.
Has no special methods. Is here to provides erased identity for
SingletonType
.- Definition Classes
- Types
-
abstract
type
SuperType >: Null <: Universe.SuperTypeApi with Universe.SingletonType
The
SuperType
type is not directly written, but arises whenC.super
is used as a prefix in aTypeRef
orSingleType
.The
SuperType
type is not directly written, but arises whenC.super
is used as a prefix in aTypeRef
orSingleType
. It's internal presentation isSuperType(thistpe, supertpe)
Here,
thistpe
is the type of the corresponding this-type. For instance, in the type arising from C.super, thethistpe
part would beThisType(C)
.supertpe
is the type of the super class referred to by thesuper
.- Definition Classes
- Types
-
trait
SuperTypeApi extends Universe.TypeApi
The API that all super types support.
The API that all super types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
SuperTypeExtractor extends AnyRef
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)
- Definition Classes
- Types
-
abstract
type
ThisType >: Null <: Universe.ThisTypeApi with Universe.SingletonType
A singleton type that describes types of the form on the left with the corresponding
ThisType
representation to the right:A singleton type that describes types of the form on the left with the corresponding
ThisType
representation to the right:C.this.type ThisType(C)
- Definition Classes
- Types
-
trait
ThisTypeApi extends Universe.TypeApi
The API that all this types support.
The API that all this types support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
ThisTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax
ThisType(sym)
wheresym
is the class prefix of the this type.An extractor class to create and pattern match with syntax
ThisType(sym)
wheresym
is the class prefix of the this type.- Definition Classes
- Types
-
abstract
type
Type >: Null <: Universe.TypeApi
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).
- Definition Classes
- Types
-
abstract
class
TypeApi extends AnyRef
The API of types.
The API of types. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
type
TypeBounds >: Null <: Universe.TypeBoundsApi with Universe.Type
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)
- Definition Classes
- Types
-
trait
TypeBoundsApi extends Universe.TypeApi
The API that all type bounds support.
The API that all type bounds support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
TypeBoundsExtractor extends AnyRef
An extractor class to create and pattern match with syntax
TypeBound(lower, upper)
Here,lower
is the lower bound of theTypeBounds
pair, andupper
is the upper bound.An extractor class to create and pattern match with syntax
TypeBound(lower, upper)
Here,lower
is the lower bound of theTypeBounds
pair, andupper
is the upper bound.- Definition Classes
- Types
-
abstract
type
TypeRef >: Null <: Universe.TypeRefApi with Universe.Type
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)
- Definition Classes
- Types
-
trait
TypeRefApi extends Universe.TypeApi
The API that all type refs support.
The API that all type refs support. The main source of information about types is the scala.reflect.api.Types page.
- Definition Classes
- Types
-
abstract
class
TypeRefExtractor extends AnyRef
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, andargs
is a possible empty list of type arguments.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, andargs
is a possible empty list of type arguments.- Definition Classes
- Types
-
abstract
type
ArrayArgument >: Null <: Universe.ArrayArgumentApi with Universe.JavaArgument
An array argument to a Java annotation as in
@Target(value={TYPE,FIELD,METHOD,PARAMETER})
An array argument to a Java annotation as in
@Target(value={TYPE,FIELD,METHOD,PARAMETER})
- Definition Classes
- Annotations
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
Annotation.tree
to inspect annotation arguments
-
trait
ArrayArgumentApi extends AnyRef
API of
ArrayArgument
instances.API of
ArrayArgument
instances. The main source of information about annotations is the scala.reflect.api.Annotations page.- Definition Classes
- Annotations
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
Annotation.tree
to inspect annotation arguments
-
abstract
class
ArrayArgumentExtractor extends AnyRef
An extractor class to create and pattern match with syntax
ArrayArgument(args)
whereargs
is the argument array.An extractor class to create and pattern match with syntax
ArrayArgument(args)
whereargs
is the argument array.- Definition Classes
- Annotations
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
Annotation.tree
to inspect annotation arguments
-
abstract
type
JavaArgument >: Null <: Universe.JavaArgumentApi
A Java annotation argument
A Java annotation argument
- Definition Classes
- Annotations
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
Annotation.tree
to inspect annotation arguments
-
trait
JavaArgumentApi extends AnyRef
Has no special methods.
Has no special methods. Is here to provides erased identity for
CompoundType
.- Definition Classes
- Annotations
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
Annotation.tree
to inspect annotation arguments
-
abstract
type
LiteralArgument >: Null <: Universe.LiteralArgumentApi with Universe.JavaArgument
A literal argument to a Java annotation as
"use X instead"
in@Deprecated("use X instead")
A literal argument to a Java annotation as
"use X instead"
in@Deprecated("use X instead")
- Definition Classes
- Annotations
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
Annotation.tree
to inspect annotation arguments
-
trait
LiteralArgumentApi extends AnyRef
The API of
LiteralArgument
instances.The API of
LiteralArgument
instances. The main source of information about annotations is the scala.reflect.api.Annotations page.- Definition Classes
- Annotations
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
Annotation.tree
to inspect annotation arguments
-
abstract
class
LiteralArgumentExtractor extends AnyRef
An extractor class to create and pattern match with syntax
LiteralArgument(value)
wherevalue
is the constant argument.An extractor class to create and pattern match with syntax
LiteralArgument(value)
wherevalue
is the constant argument.- Definition Classes
- Annotations
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
Annotation.tree
to inspect annotation arguments
-
abstract
type
NestedArgument >: Null <: Universe.NestedArgumentApi with Universe.JavaArgument
A nested annotation argument to a Java annotation as
@Nested
in@Outer(@Nested)
.A nested annotation argument to a Java annotation as
@Nested
in@Outer(@Nested)
.- Definition Classes
- Annotations
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
Annotation.tree
to inspect annotation arguments
-
trait
NestedArgumentApi extends AnyRef
API of
NestedArgument
instances.API of
NestedArgument
instances. The main source of information about annotations is the scala.reflect.api.Annotations page.- Definition Classes
- Annotations
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
Annotation.tree
to inspect annotation arguments
-
abstract
class
NestedArgumentExtractor extends AnyRef
An extractor class to create and pattern match with syntax
NestedArgument(annotation)
whereannotation
is the nested annotation.An extractor class to create and pattern match with syntax
NestedArgument(annotation)
whereannotation
is the nested annotation.- Definition Classes
- Annotations
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
Annotation.tree
to inspect annotation arguments
-
type
BuildApi = ReificationSupportApi
- Definition Classes
- Internals
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
internal.ReificationSupportApi
instead
-
type
ModifiersCreator = ModifiersExtractor
- Definition Classes
- Trees
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use ModifiersExtractor instead
Abstract Value Members
-
abstract
val
Alternative: AlternativeExtractor
The constructor/extractor for
Alternative
instances.The constructor/extractor for
Alternative
instances.- Definition Classes
- Trees
-
implicit abstract
val
AlternativeTag: ClassTag[Alternative]
- Definition Classes
- ImplicitTags
-
abstract
val
Annotated: AnnotatedExtractor
The constructor/extractor for
Annotated
instances.The constructor/extractor for
Annotated
instances.- Definition Classes
- Trees
-
implicit abstract
val
AnnotatedTag: ClassTag[Annotated]
- Definition Classes
- ImplicitTags
-
abstract
val
AnnotatedType: AnnotatedTypeExtractor
The constructor/extractor for
AnnotatedType
instances.The constructor/extractor for
AnnotatedType
instances.- Definition Classes
- Types
-
implicit abstract
val
AnnotatedTypeTag: ClassTag[AnnotatedType]
- Definition Classes
- ImplicitTags
-
abstract
val
Annotation: AnnotationExtractor
The constructor/extractor for
Annotation
instances.The constructor/extractor for
Annotation
instances.- Definition Classes
- Annotations
-
implicit abstract
val
AnnotationTag: ClassTag[Annotation]
- Definition Classes
- ImplicitTags
-
abstract
val
AppliedTypeTree: AppliedTypeTreeExtractor
The constructor/extractor for
AppliedTypeTree
instances.The constructor/extractor for
AppliedTypeTree
instances.- Definition Classes
- Trees
-
implicit abstract
val
AppliedTypeTreeTag: ClassTag[AppliedTypeTree]
- Definition Classes
- ImplicitTags
-
abstract
val
Apply: ApplyExtractor
The constructor/extractor for
Apply
instances.The constructor/extractor for
Apply
instances.- Definition Classes
- Trees
-
implicit abstract
val
ApplyTag: ClassTag[Apply]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
ArrayArgumentTag: ClassTag[ArrayArgument]
- Definition Classes
- ImplicitTags
-
abstract
val
Assign: AssignExtractor
The constructor/extractor for
Assign
instances.The constructor/extractor for
Assign
instances.- Definition Classes
- Trees
-
abstract
val
AssignOrNamedArg: AssignOrNamedArgExtractor
The constructor/extractor for
AssignOrNamedArg
instances.The constructor/extractor for
AssignOrNamedArg
instances.- Definition Classes
- Trees
-
implicit abstract
val
AssignOrNamedArgTag: ClassTag[AssignOrNamedArg]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
AssignTag: ClassTag[Assign]
- Definition Classes
- ImplicitTags
-
abstract
val
Bind: BindExtractor
The constructor/extractor for
Bind
instances.The constructor/extractor for
Bind
instances.- Definition Classes
- Trees
-
implicit abstract
val
BindTag: ClassTag[Bind]
- Definition Classes
- ImplicitTags
-
abstract
val
Block: BlockExtractor
The constructor/extractor for
Block
instances.The constructor/extractor for
Block
instances.- Definition Classes
- Trees
-
implicit abstract
val
BlockTag: ClassTag[Block]
- Definition Classes
- ImplicitTags
-
abstract
val
BoundedWildcardType: BoundedWildcardTypeExtractor
The constructor/extractor for
BoundedWildcardType
instances.The constructor/extractor for
BoundedWildcardType
instances.- Definition Classes
- Types
-
implicit abstract
val
BoundedWildcardTypeTag: ClassTag[BoundedWildcardType]
- Definition Classes
- ImplicitTags
-
abstract
val
CaseDef: CaseDefExtractor
The constructor/extractor for
CaseDef
instances.The constructor/extractor for
CaseDef
instances.- Definition Classes
- Trees
-
implicit abstract
val
CaseDefTag: ClassTag[CaseDef]
- Definition Classes
- ImplicitTags
-
abstract
val
ClassDef: ClassDefExtractor
The constructor/extractor for
ClassDef
instances.The constructor/extractor for
ClassDef
instances.- Definition Classes
- Trees
-
implicit abstract
val
ClassDefTag: ClassTag[ClassDef]
- Definition Classes
- ImplicitTags
-
abstract
val
ClassInfoType: ClassInfoTypeExtractor
The constructor/extractor for
ClassInfoType
instances.The constructor/extractor for
ClassInfoType
instances.- Definition Classes
- Types
-
implicit abstract
val
ClassInfoTypeTag: ClassTag[ClassInfoType]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
ClassSymbolTag: ClassTag[ClassSymbol]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
CompoundTypeTag: ClassTag[CompoundType]
- Definition Classes
- ImplicitTags
-
abstract
val
CompoundTypeTree: CompoundTypeTreeExtractor
The constructor/extractor for
CompoundTypeTree
instances.The constructor/extractor for
CompoundTypeTree
instances.- Definition Classes
- Trees
-
implicit abstract
val
CompoundTypeTreeTag: ClassTag[CompoundTypeTree]
- Definition Classes
- ImplicitTags
-
abstract
val
Constant: ConstantExtractor
The constructor/extractor for
Constant
instances.The constructor/extractor for
Constant
instances.- Definition Classes
- Constants
-
implicit abstract
val
ConstantTag: ClassTag[Constant]
- Definition Classes
- ImplicitTags
-
abstract
val
ConstantType: ConstantTypeExtractor
The constructor/extractor for
ConstantType
instances.The constructor/extractor for
ConstantType
instances.- Definition Classes
- Types
-
implicit abstract
val
ConstantTypeTag: ClassTag[ConstantType]
- Definition Classes
- ImplicitTags
-
abstract
val
DefDef: DefDefExtractor
The constructor/extractor for
DefDef
instances.The constructor/extractor for
DefDef
instances.- Definition Classes
- Trees
-
implicit abstract
val
DefDefTag: ClassTag[DefDef]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
DefTreeTag: ClassTag[DefTree]
- Definition Classes
- ImplicitTags
-
abstract
val
EmptyTree: Tree
The empty tree
The empty tree
- Definition Classes
- Trees
-
abstract
val
ExistentialType: ExistentialTypeExtractor
The constructor/extractor for
ExistentialType
instances.The constructor/extractor for
ExistentialType
instances.- Definition Classes
- Types
-
implicit abstract
val
ExistentialTypeTag: ClassTag[ExistentialType]
- Definition Classes
- ImplicitTags
-
abstract
val
ExistentialTypeTree: ExistentialTypeTreeExtractor
The constructor/extractor for
ExistentialTypeTree
instances.The constructor/extractor for
ExistentialTypeTree
instances.- Definition Classes
- Trees
-
implicit abstract
val
ExistentialTypeTreeTag: ClassTag[ExistentialTypeTree]
- Definition Classes
- ImplicitTags
-
abstract
val
Flag: FlagValues
A module that contains all possible values that can constitute flag sets.
A module that contains all possible values that can constitute flag sets.
- Definition Classes
- FlagSets
-
implicit abstract
val
FlagSetTag: ClassTag[FlagSet]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
FreeTermSymbolTag: ClassTag[FreeTermSymbol]
Tag that preserves the identity of
FreeTermSymbol
in the face of erasure.Tag that preserves the identity of
FreeTermSymbol
in the face of erasure. Can be used for pattern matching, instance tests, serialization and the like.- Definition Classes
- Internals
-
implicit abstract
val
FreeTypeSymbolTag: ClassTag[FreeTypeSymbol]
Tag that preserves the identity of
FreeTermSymbol
in the face of erasure.Tag that preserves the identity of
FreeTermSymbol
in the face of erasure. Can be used for pattern matching, instance tests, serialization and the like.- Definition Classes
- Internals
-
abstract
val
Function: FunctionExtractor
The constructor/extractor for
Function
instances.The constructor/extractor for
Function
instances.- Definition Classes
- Trees
-
implicit abstract
val
FunctionTag: ClassTag[Function]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
GenericApplyTag: ClassTag[GenericApply]
- Definition Classes
- ImplicitTags
-
abstract
def
Ident(sym: Symbol): Ident
A factory method for
Ident
nodes.A factory method for
Ident
nodes.- Definition Classes
- Trees
-
abstract
val
Ident: IdentExtractor
The constructor/extractor for
Ident
instances.The constructor/extractor for
Ident
instances.- Definition Classes
- Trees
-
implicit abstract
val
IdentTag: ClassTag[Ident]
- Definition Classes
- ImplicitTags
-
abstract
val
If: IfExtractor
The constructor/extractor for
If
instances.The constructor/extractor for
If
instances.- Definition Classes
- Trees
-
implicit abstract
val
IfTag: ClassTag[If]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
ImplDefTag: ClassTag[ImplDef]
- Definition Classes
- ImplicitTags
-
abstract
val
Import: ImportExtractor
The constructor/extractor for
Import
instances.The constructor/extractor for
Import
instances.- Definition Classes
- Trees
-
abstract
val
ImportSelector: ImportSelectorExtractor
The constructor/extractor for
ImportSelector
instances.The constructor/extractor for
ImportSelector
instances.- Definition Classes
- Trees
-
implicit abstract
val
ImportSelectorTag: ClassTag[ImportSelector]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
ImportTag: ClassTag[Import]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
JavaArgumentTag: ClassTag[JavaArgument]
- Definition Classes
- ImplicitTags
-
abstract
val
LabelDef: LabelDefExtractor
The constructor/extractor for
LabelDef
instances.The constructor/extractor for
LabelDef
instances.- Definition Classes
- Trees
-
implicit abstract
val
LabelDefTag: ClassTag[LabelDef]
- Definition Classes
- ImplicitTags
-
abstract
val
Literal: LiteralExtractor
The constructor/extractor for
Literal
instances.The constructor/extractor for
Literal
instances.- Definition Classes
- Trees
-
implicit abstract
val
LiteralArgumentTag: ClassTag[LiteralArgument]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
LiteralTag: ClassTag[Literal]
- Definition Classes
- ImplicitTags
-
abstract
val
Match: MatchExtractor
The constructor/extractor for
Match
instances.The constructor/extractor for
Match
instances.- Definition Classes
- Trees
-
implicit abstract
val
MatchTag: ClassTag[Match]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
MemberDefTag: ClassTag[MemberDef]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
MemberScopeTag: ClassTag[MemberScope]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
MethodSymbolTag: ClassTag[MethodSymbol]
- Definition Classes
- ImplicitTags
-
abstract
val
MethodType: MethodTypeExtractor
The constructor/extractor for
MethodType
instances.The constructor/extractor for
MethodType
instances.- Definition Classes
- Types
-
implicit abstract
val
MethodTypeTag: ClassTag[MethodType]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
MirrorTag: ClassTag[Mirror]
- Definition Classes
- ImplicitTags
-
abstract
val
Modifiers: ModifiersExtractor
The constructor/extractor for
Modifiers
instances.The constructor/extractor for
Modifiers
instances.- Definition Classes
- Trees
-
implicit abstract
val
ModifiersTag: ClassTag[Modifiers]
- Definition Classes
- ImplicitTags
-
abstract
val
ModuleDef: ModuleDefExtractor
The constructor/extractor for
ModuleDef
instances.The constructor/extractor for
ModuleDef
instances.- Definition Classes
- Trees
-
implicit abstract
val
ModuleDefTag: ClassTag[ModuleDef]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
ModuleSymbolTag: ClassTag[ModuleSymbol]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
NameTag: ClassTag[Name]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
NameTreeTag: ClassTag[NameTree]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
NestedArgumentTag: ClassTag[NestedArgument]
- Definition Classes
- ImplicitTags
-
abstract
val
New: NewExtractor
The constructor/extractor for
New
instances.The constructor/extractor for
New
instances.- Definition Classes
- Trees
-
implicit abstract
val
NewTag: ClassTag[New]
- Definition Classes
- ImplicitTags
-
abstract
val
NoFlags: FlagSet
The empty set of flags
The empty set of flags
- Definition Classes
- FlagSets
-
abstract
val
NoPosition: Position
A special "missing" position.
A special "missing" position.
- Definition Classes
- Positions
-
abstract
val
NoPrefix: Type
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 asSingleType(NoPrefix, <x>)
, where<x>
stands for the symbol forx
.- Definition Classes
- Types
-
abstract
val
NoSymbol: Symbol
A special "missing" symbol.
A special "missing" symbol. Commonly used in the API to denote a default or empty value.
- Definition Classes
- Symbols
-
abstract
val
NoType: Type
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.
- Definition Classes
- Types
-
abstract
val
NullaryMethodType: NullaryMethodTypeExtractor
The constructor/extractor for
NullaryMethodType
instances.The constructor/extractor for
NullaryMethodType
instances.- Definition Classes
- Types
-
implicit abstract
val
NullaryMethodTypeTag: ClassTag[NullaryMethodType]
- Definition Classes
- ImplicitTags
-
abstract
val
PackageDef: PackageDefExtractor
The constructor/extractor for
PackageDef
instances.The constructor/extractor for
PackageDef
instances.- Definition Classes
- Trees
-
implicit abstract
val
PackageDefTag: ClassTag[PackageDef]
- Definition Classes
- ImplicitTags
-
abstract
val
PolyType: PolyTypeExtractor
The constructor/extractor for
PolyType
instances.The constructor/extractor for
PolyType
instances.- Definition Classes
- Types
-
implicit abstract
val
PolyTypeTag: ClassTag[PolyType]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
PositionTag: ClassTag[Position]
- Definition Classes
- ImplicitTags
-
abstract
val
RefTree: RefTreeExtractor
The constructor/extractor for
RefTree
instances.The constructor/extractor for
RefTree
instances.- Definition Classes
- Trees
-
implicit abstract
val
RefTreeTag: ClassTag[RefTree]
- Definition Classes
- ImplicitTags
-
abstract
val
ReferenceToBoxed: ReferenceToBoxedExtractor
The constructor/extractor for
ReferenceToBoxed
instances.The constructor/extractor for
ReferenceToBoxed
instances.- Definition Classes
- Internals
-
implicit abstract
val
ReferenceToBoxedTag: ClassTag[ReferenceToBoxed]
Tag that preserves the identity of
ReferenceToBoxed
in the face of erasure.Tag that preserves the identity of
ReferenceToBoxed
in the face of erasure. Can be used for pattern matching, instance tests, serialization and the like.- Definition Classes
- Internals
-
abstract
val
RefinedType: RefinedTypeExtractor
The constructor/extractor for
RefinedType
instances.The constructor/extractor for
RefinedType
instances.- Definition Classes
- Types
-
implicit abstract
val
RefinedTypeTag: ClassTag[RefinedType]
- Definition Classes
- ImplicitTags
-
abstract
val
Return: ReturnExtractor
The constructor/extractor for
Return
instances.The constructor/extractor for
Return
instances.- Definition Classes
- Trees
-
implicit abstract
val
ReturnTag: ClassTag[Return]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
ScopeTag: ClassTag[Scope]
- Definition Classes
- ImplicitTags
-
abstract
def
Select(qualifier: Tree, sym: Symbol): Select
A factory method for
Select
nodes.A factory method for
Select
nodes.- Definition Classes
- Trees
-
abstract
val
Select: SelectExtractor
The constructor/extractor for
Select
instances.The constructor/extractor for
Select
instances.- Definition Classes
- Trees
-
abstract
val
SelectFromTypeTree: SelectFromTypeTreeExtractor
The constructor/extractor for
SelectFromTypeTree
instances.The constructor/extractor for
SelectFromTypeTree
instances.- Definition Classes
- Trees
-
implicit abstract
val
SelectFromTypeTreeTag: ClassTag[SelectFromTypeTree]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
SelectTag: ClassTag[Select]
- Definition Classes
- ImplicitTags
-
abstract
val
SingleType: SingleTypeExtractor
The constructor/extractor for
SingleType
instances.The constructor/extractor for
SingleType
instances.- Definition Classes
- Types
-
implicit abstract
val
SingleTypeTag: ClassTag[SingleType]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
SingletonTypeTag: ClassTag[SingletonType]
- Definition Classes
- ImplicitTags
-
abstract
val
SingletonTypeTree: SingletonTypeTreeExtractor
The constructor/extractor for
SingletonTypeTree
instances.The constructor/extractor for
SingletonTypeTree
instances.- Definition Classes
- Trees
-
implicit abstract
val
SingletonTypeTreeTag: ClassTag[SingletonTypeTree]
- Definition Classes
- ImplicitTags
-
abstract
val
Star: StarExtractor
The constructor/extractor for
Star
instances.The constructor/extractor for
Star
instances.- Definition Classes
- Trees
-
implicit abstract
val
StarTag: ClassTag[Star]
- Definition Classes
- ImplicitTags
-
abstract
val
Super: SuperExtractor
The constructor/extractor for
Super
instances.The constructor/extractor for
Super
instances.- Definition Classes
- Trees
-
implicit abstract
val
SuperTag: ClassTag[Super]
- Definition Classes
- ImplicitTags
-
abstract
val
SuperType: SuperTypeExtractor
The constructor/extractor for
SuperType
instances.The constructor/extractor for
SuperType
instances.- Definition Classes
- Types
-
implicit abstract
val
SuperTypeTag: ClassTag[SuperType]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
SymTreeTag: ClassTag[SymTree]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
SymbolTag: ClassTag[Symbol]
- Definition Classes
- ImplicitTags
-
abstract
val
Template: TemplateExtractor
The constructor/extractor for
Template
instances.The constructor/extractor for
Template
instances.- Definition Classes
- Trees
-
implicit abstract
val
TemplateTag: ClassTag[Template]
- Definition Classes
- ImplicitTags
-
abstract
val
TermName: TermNameExtractor
The constructor/extractor for
TermName
instances.The constructor/extractor for
TermName
instances.- Definition Classes
- Names
-
implicit abstract
val
TermNameTag: ClassTag[TermName]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
TermSymbolTag: ClassTag[TermSymbol]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
TermTreeTag: ClassTag[TermTree]
- Definition Classes
- ImplicitTags
-
abstract
def
This(sym: Symbol): Tree
A factory method for
This
nodes.A factory method for
This
nodes.- Definition Classes
- Trees
-
abstract
val
This: ThisExtractor
The constructor/extractor for
This
instances.The constructor/extractor for
This
instances.- Definition Classes
- Trees
-
implicit abstract
val
ThisTag: ClassTag[This]
- Definition Classes
- ImplicitTags
-
abstract
val
ThisType: ThisTypeExtractor
The constructor/extractor for
ThisType
instances.The constructor/extractor for
ThisType
instances.- Definition Classes
- Types
-
implicit abstract
val
ThisTypeTag: ClassTag[ThisType]
- Definition Classes
- ImplicitTags
-
abstract
val
Throw: ThrowExtractor
The constructor/extractor for
Throw
instances.The constructor/extractor for
Throw
instances.- Definition Classes
- Trees
-
implicit abstract
val
ThrowTag: ClassTag[Throw]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
TreeCopierTag: ClassTag[TreeCopier]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
TreeTag: ClassTag[Tree]
- Definition Classes
- ImplicitTags
-
abstract
val
Try: TryExtractor
The constructor/extractor for
Try
instances.The constructor/extractor for
Try
instances.- Definition Classes
- Trees
-
implicit abstract
val
TryTag: ClassTag[Try]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
TypTreeTag: ClassTag[TypTree]
- Definition Classes
- ImplicitTags
-
abstract
val
TypeApply: TypeApplyExtractor
The constructor/extractor for
TypeApply
instances.The constructor/extractor for
TypeApply
instances.- Definition Classes
- Trees
-
implicit abstract
val
TypeApplyTag: ClassTag[TypeApply]
- Definition Classes
- ImplicitTags
-
abstract
val
TypeBounds: TypeBoundsExtractor
The constructor/extractor for
TypeBounds
instances.The constructor/extractor for
TypeBounds
instances.- Definition Classes
- Types
-
implicit abstract
val
TypeBoundsTag: ClassTag[TypeBounds]
- Definition Classes
- ImplicitTags
-
abstract
val
TypeBoundsTree: TypeBoundsTreeExtractor
The constructor/extractor for
TypeBoundsTree
instances.The constructor/extractor for
TypeBoundsTree
instances.- Definition Classes
- Trees
-
implicit abstract
val
TypeBoundsTreeTag: ClassTag[TypeBoundsTree]
- Definition Classes
- ImplicitTags
-
abstract
val
TypeDef: TypeDefExtractor
The constructor/extractor for
TypeDef
instances.The constructor/extractor for
TypeDef
instances.- Definition Classes
- Trees
-
implicit abstract
val
TypeDefTag: ClassTag[TypeDef]
- Definition Classes
- ImplicitTags
-
abstract
val
TypeName: TypeNameExtractor
The constructor/extractor for
TypeName
instances.The constructor/extractor for
TypeName
instances.- Definition Classes
- Names
-
implicit abstract
val
TypeNameTag: ClassTag[TypeName]
- Definition Classes
- ImplicitTags
-
abstract
val
TypeRef: TypeRefExtractor
The constructor/extractor for
TypeRef
instances.The constructor/extractor for
TypeRef
instances.- Definition Classes
- Types
-
implicit abstract
val
TypeRefTag: ClassTag[TypeRef]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
TypeSymbolTag: ClassTag[TypeSymbol]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
TypeTagg: ClassTag[Type]
- Definition Classes
- ImplicitTags
-
abstract
def
TypeTree(tp: Type): TypeTree
A factory method for
TypeTree
nodes.A factory method for
TypeTree
nodes.- Definition Classes
- Trees
-
abstract
val
TypeTree: TypeTreeExtractor
The constructor/extractor for
TypeTree
instances.The constructor/extractor for
TypeTree
instances.- Definition Classes
- Trees
-
implicit abstract
val
TypeTreeTag: ClassTag[TypeTree]
- Definition Classes
- ImplicitTags
-
abstract
val
Typed: TypedExtractor
The constructor/extractor for
Typed
instances.The constructor/extractor for
Typed
instances.- Definition Classes
- Trees
-
implicit abstract
val
TypedTag: ClassTag[Typed]
- Definition Classes
- ImplicitTags
-
abstract
val
UnApply: UnApplyExtractor
The constructor/extractor for
UnApply
instances.The constructor/extractor for
UnApply
instances.- Definition Classes
- Trees
-
implicit abstract
val
UnApplyTag: ClassTag[UnApply]
- Definition Classes
- ImplicitTags
-
abstract
val
ValDef: ValDefExtractor
The constructor/extractor for
ValDef
instances.The constructor/extractor for
ValDef
instances.- Definition Classes
- Trees
-
implicit abstract
val
ValDefTag: ClassTag[ValDef]
- Definition Classes
- ImplicitTags
-
implicit abstract
val
ValOrDefDefTag: ClassTag[ValOrDefDef]
- Definition Classes
- ImplicitTags
-
abstract
val
WildcardType: Type
An object representing an unknown type, used during type inference.
An object representing an unknown type, used during type inference. If you see WildcardType outside of inference it is almost certainly a bug.
- Definition Classes
- Types
-
implicit abstract
def
addFlagOps(left: FlagSet): FlagOps
The API of
FlagSet
instances.The API of
FlagSet
instances.- Definition Classes
- FlagSets
-
abstract
def
annotationToTree(ann: Annotation): Tree
- Attributes
- protected[scala]
- Definition Classes
- Annotations
-
abstract
def
appliedType(sym: Symbol, args: Type*): Type
- Definition Classes
- Types
- See also
-
abstract
def
appliedType(sym: Symbol, args: List[Type]): Type
- Definition Classes
- Types
- See also
-
abstract
def
appliedType(tycon: Type, args: Type*): Type
- Definition Classes
- Types
- See also
-
abstract
def
appliedType(tycon: Type, args: List[Type]): Type
A creator for type applications
A creator for type applications
- Definition Classes
- Types
-
abstract
def
atPos[T <: Tree](pos: Position)(tree: T): T
Assigns a given position to all position-less nodes of a given AST.
Assigns a given position to all position-less nodes of a given AST.
- Definition Classes
- Positions
-
abstract
val
compat: Compat
Provides enrichments to ensure source compatibility between Scala 2.10 and Scala 2.11.
Provides enrichments to ensure source compatibility between Scala 2.10 and Scala 2.11. If in your reflective program for Scala 2.10 you've used something that's now become an internal API, a single
compat._
import will fix things for you.- Definition Classes
- Internals
-
abstract
val
definitions: DefinitionsApi
A value containing all standard definitions in DefinitionsApi
A value containing all standard definitions in DefinitionsApi
- Definition Classes
- StandardDefinitions
-
abstract
def
glb(ts: List[Type]): Type
The greatest lower bound of a list of types, as determined by
<:<
.The greatest lower bound of a list of types, as determined by
<:<
.- Definition Classes
- Types
-
abstract
val
internal: Internal
- Definition Classes
- Internals
- See also
-
abstract
def
lub(xs: List[Type]): Type
The least upper bound of a list of types, as determined by
<:<
.The least upper bound of a list of types, as determined by
<:<
.- Definition Classes
- Types
-
abstract
def
newCodePrinter(out: PrintWriter, tree: Tree, printRootPkg: Boolean): TreePrinter
Hook to define what
showCode(...)
means.Hook to define what
showCode(...)
means.- Attributes
- protected
- Definition Classes
- Printers
-
abstract
def
newLazyTreeCopier: TreeCopier
Creates a lazy tree copier.
Creates a lazy tree copier.
- Definition Classes
- Trees
-
abstract
def
newRawTreePrinter(out: PrintWriter): TreePrinter
Hook to define what
showRaw(...)
means.Hook to define what
showRaw(...)
means.- Attributes
- protected
- Definition Classes
- Printers
-
abstract
def
newStrictTreeCopier: TreeCopier
Creates a strict tree copier.
Creates a strict tree copier.
- Definition Classes
- Trees
-
abstract
def
newTreePrinter(out: PrintWriter): TreePrinter
Hook to define what
show(...)
means.Hook to define what
show(...)
means.- Attributes
- protected
- Definition Classes
- Printers
-
abstract
val
noSelfType: ValDef
An empty deferred value definition corresponding to: val _: _ This is used as a placeholder in the
self
parameter Template if there is no definition of a self value of self type.An empty deferred value definition corresponding to: val _: _ This is used as a placeholder in the
self
parameter Template if there is no definition of a self value of self type.- Definition Classes
- Trees
-
abstract
val
pendingSuperCall: Apply
An empty superclass constructor call corresponding to: super.<init>() This is used as a placeholder in the primary constructor body in class templates to denote the insertion point of a call to superclass constructor after the typechecker figures out the superclass of a given template.
An empty superclass constructor call corresponding to: super.<init>() This is used as a placeholder in the primary constructor body in class templates to denote the insertion point of a call to superclass constructor after the typechecker figures out the superclass of a given template.
- Definition Classes
- Trees
-
abstract
val
rootMirror: Mirror
The root mirror of this universe.
The root mirror of this universe. This mirror contains standard Scala classes and types such as
Any
,AnyRef
,AnyVal
,Nothing
,Null
, and all classes loaded from scala-library, which are shared across all mirrors within the enclosing universe.- Definition Classes
- Mirrors
-
abstract
def
runtimeMirror(cl: ClassLoader): Mirror
Creates a runtime reflection mirror from a JVM classloader.
Creates a runtime reflection mirror from a JVM classloader.
For more information about
Mirrors
s, see scala.reflect.api.Mirrors or the Reflection Guide: Mirrors -
abstract
def
show(position: Position): String
Renders a prettified representation of a position.
Renders a prettified representation of a position.
- Definition Classes
- Printers
-
abstract
def
show(flags: FlagSet): String
Renders a prettified representation of a flag set.
Renders a prettified representation of a flag set.
- Definition Classes
- Printers
-
abstract
def
show(name: Name): String
Renders a prettified representation of a name.
Renders a prettified representation of a name.
- Definition Classes
- Printers
-
abstract
def
showDecl(sym: Symbol): String
Renders a string that represents a declaration of this symbol written in Scala.
Renders a string that represents a declaration of this symbol written in Scala.
- Definition Classes
- Printers
-
abstract
def
symbolOf[T](implicit arg0: WeakTypeTag[T]): TypeSymbol
Type symbol of
x
as derived from a type tag.Type symbol of
x
as derived from a type tag.- Definition Classes
- TypeTags
-
abstract
val
termNames: TermNamesApi
A value containing all standard term names.
A value containing all standard term names.
- Definition Classes
- StandardNames
-
abstract
def
treeToAnnotation(tree: Tree): Annotation
- Attributes
- protected[scala]
- Definition Classes
- Annotations
-
abstract
val
typeNames: TypeNamesApi
A value containing all standard type names.
A value containing all standard type names.
- Definition Classes
- StandardNames
-
abstract
def
wrappingPos(trees: List[Tree]): Position
A position that wraps the non-empty set of trees.
A position that wraps the non-empty set of trees. The point of the wrapping position is the point of the first trees' position. If all some the trees are non-synthetic, returns a range position enclosing the non-synthetic trees Otherwise returns a synthetic offset position to point.
- Definition Classes
- Positions
-
abstract
def
wrappingPos(default: Position, trees: List[Tree]): Position
A position that wraps a set of trees.
A position that wraps a set of trees. The point of the wrapping position is the point of the default position. If some of the trees are ranges, returns a range position enclosing all ranges Otherwise returns default position.
- Definition Classes
- Positions
-
abstract
def
Apply(sym: Symbol, args: Tree*): Tree
A factory method for
Apply
nodes.A factory method for
Apply
nodes.- Definition Classes
- Trees
- Annotations
- @deprecated
- Deprecated
(Since version 2.10.1) use q"$sym(..$args)" instead
-
abstract
def
ApplyConstructor(tpt: Tree, args: List[Tree]): Tree
0-1 argument list new, based on a type tree.
0-1 argument list new, based on a type tree.
- Definition Classes
- Trees
- Annotations
- @deprecated
- Deprecated
(Since version 2.10.1) use q"new $tpt(..$args)" instead
-
abstract
val
ArrayArgument: ArrayArgumentExtractor
The constructor/extractor for
ArrayArgument
instances.The constructor/extractor for
ArrayArgument
instances.- Definition Classes
- Annotations
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
Annotation.tree
to inspect annotation arguments
-
abstract
def
Bind(sym: Symbol, body: Tree): Bind
A factory method for
Bind
nodes.A factory method for
Bind
nodes.- Definition Classes
- Trees
- Annotations
- @deprecated
- Deprecated
(Since version 2.10.1) use the canonical Bind constructor to create a bind and then initialize its symbol manually
-
abstract
def
Block(stats: Tree*): Block
A factory method for
Block
nodes.A factory method for
Block
nodes. Flattens directly nested blocks.- Definition Classes
- Trees
- Annotations
- @deprecated
- Deprecated
(Since version 2.10.1) use q"{..$stats}" instead. Flatten directly nested blocks manually if needed
-
abstract
def
CaseDef(pat: Tree, body: Tree): CaseDef
A factory method for
CaseDef
nodes.A factory method for
CaseDef
nodes.- Definition Classes
- Trees
- Annotations
- @deprecated
- Deprecated
(Since version 2.10.1) use cq"$pat => $body" instead
-
abstract
def
Ident(name: String): Ident
A factory method for
Ident
nodes.A factory method for
Ident
nodes.- Definition Classes
- Trees
- Annotations
- @deprecated
- Deprecated
(Since version 2.10.1) use Ident(TermName(name)) instead
-
abstract
val
LiteralArgument: LiteralArgumentExtractor
The constructor/extractor for
LiteralArgument
instances.The constructor/extractor for
LiteralArgument
instances.- Definition Classes
- Annotations
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
Annotation.tree
to inspect annotation arguments
-
abstract
val
NestedArgument: NestedArgumentExtractor
The constructor/extractor for
NestedArgument
instances.The constructor/extractor for
NestedArgument
instances.- Definition Classes
- Annotations
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
Annotation.tree
to inspect annotation arguments
-
abstract
def
New(sym: Symbol, args: Tree*): Tree
0-1 argument list new, based on a symbol.
0-1 argument list new, based on a symbol.
- Definition Classes
- Trees
- Annotations
- @deprecated
- Deprecated
(Since version 2.10.1) use q"new ${sym.toType}(..$args)" instead
-
abstract
def
New(tpe: Type, args: Tree*): Tree
0-1 argument list new, based on a type.
0-1 argument list new, based on a type.
- Definition Classes
- Trees
- Annotations
- @deprecated
- Deprecated
(Since version 2.10.1) use q"new $tpe(..$args)" instead
-
abstract
def
New(tpt: Tree, argss: List[List[Tree]]): Tree
Factory method for object creation
new tpt(args_1)...(args_n)
ANew(t, as)
is expanded to:(new t).<init>(as)
Factory method for object creation
new tpt(args_1)...(args_n)
ANew(t, as)
is expanded to:(new t).<init>(as)
- Definition Classes
- Trees
- Annotations
- @deprecated
- Deprecated
(Since version 2.10.1) use q"new $tpt(...$argss)" instead
-
abstract
def
Select(qualifier: Tree, name: String): Select
A factory method for
Select
nodes. -
abstract
def
Super(sym: Symbol, mix: TypeName): Tree
A factory method for
Super
nodes.A factory method for
Super
nodes.- Definition Classes
- Trees
- Annotations
- @deprecated
- Deprecated
(Since version 2.10.1) use q"$sym.super[$mix].x".qualifier instead
-
abstract
def
Throw(tpe: Type, args: Tree*): Throw
A factory method for
Throw
nodes.A factory method for
Throw
nodes.- Definition Classes
- Trees
- Annotations
- @deprecated
- Deprecated
(Since version 2.10.1) use q"throw new $tpe(..$args)" instead
-
abstract
def
Try(body: Tree, cases: (Tree, Tree)*): Try
A factory method for
Try
nodes.A factory method for
Try
nodes.- Definition Classes
- Trees
- Annotations
- @deprecated
- Deprecated
(Since version 2.10.1) convert cases into casedefs and use q"try $body catch { case ..$newcases }" instead
-
abstract
val
build: ReificationSupportApi
- Definition Classes
- Internals
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
internal.reificationSupport
instead
-
abstract
val
emptyValDef: ValDef
- Definition Classes
- Trees
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
noSelfType
instead
-
abstract
def
newTermName(s: String): TermName
Create a new term name.
Create a new term name.
- Definition Classes
- Names
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use TermName instead
-
abstract
def
newTypeName(s: String): TypeName
Creates a new type name.
Creates a new type name.
- Definition Classes
- Names
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use TypeName instead
-
abstract
val
nme: TermNamesApi
- Definition Classes
- StandardNames
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
termNames
instead- See also
-
abstract
val
tpnme: TypeNamesApi
- Definition Classes
- StandardNames
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
typeNames
instead- See also
Concrete Value Members
-
object
Expr extends Serializable
Constructor/Extractor for Expr.
Constructor/Extractor for Expr.
Can be useful, when having a tree and wanting to splice it in reify call, in which case the tree first needs to be wrapped in an expr.
The main source of information about exprs is the scala.reflect.api.Exprs page.
- Definition Classes
- Exprs
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
def
+(other: String): String
- Implicit
- This member is added by an implicit conversion from JavaUniverse to any2stringadd[JavaUniverse] performed by method any2stringadd in scala.Predef.
- Definition Classes
- any2stringadd
-
def
->[B](y: B): (JavaUniverse, B)
- Implicit
- This member is added by an implicit conversion from JavaUniverse to ArrowAssoc[JavaUniverse] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @inline()
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
Modifiers(flags: FlagSet): Modifiers
The factory for
Modifiers
instances.The factory for
Modifiers
instances.- Definition Classes
- Trees
-
def
Modifiers(flags: FlagSet, privateWithin: Name): Modifiers
The factory for
Modifiers
instances.The factory for
Modifiers
instances.- Definition Classes
- Trees
-
lazy val
NoMods: Modifiers
An empty
Modifiers
object: no flags, empty visibility annotation and no Scala annotations.An empty
Modifiers
object: no flags, empty visibility annotation and no Scala annotations.- Definition Classes
- Trees
-
implicit
val
RuntimeClassTag: ClassTag[RuntimeClass]
- Definition Classes
- JavaUniverse → ImplicitTags
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
def
ensuring(cond: (JavaUniverse) ⇒ Boolean, msg: ⇒ Any): JavaUniverse
- Implicit
- This member is added by an implicit conversion from JavaUniverse to Ensuring[JavaUniverse] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
-
def
ensuring(cond: (JavaUniverse) ⇒ Boolean): JavaUniverse
- Implicit
- This member is added by an implicit conversion from JavaUniverse to Ensuring[JavaUniverse] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
-
def
ensuring(cond: Boolean, msg: ⇒ Any): JavaUniverse
- Implicit
- This member is added by an implicit conversion from JavaUniverse to Ensuring[JavaUniverse] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
-
def
ensuring(cond: Boolean): JavaUniverse
- Implicit
- This member is added by an implicit conversion from JavaUniverse to Ensuring[JavaUniverse] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
formatted(fmtstr: String): String
- Implicit
- This member is added by an implicit conversion from JavaUniverse to StringFormat[JavaUniverse] performed by method StringFormat in scala.Predef.
- Definition Classes
- StringFormat
- Annotations
- @inline()
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
itransform(transformer: Transformer, tree: Tree): Tree
Delegates the transformation strategy to
scala.reflect.internal.Trees
, because pattern matching on abstract types we have here degrades performance.Delegates the transformation strategy to
scala.reflect.internal.Trees
, because pattern matching on abstract types we have here degrades performance.- Attributes
- protected
- Definition Classes
- Trees
-
def
itraverse(traverser: Traverser, tree: Tree): Unit
Delegates the traversal strategy to
scala.reflect.internal.Trees
, because pattern matching on abstract types we have here degrades performance.Delegates the traversal strategy to
scala.reflect.internal.Trees
, because pattern matching on abstract types we have here degrades performance.- Attributes
- protected
- Definition Classes
- Trees
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
macro
def
reify[T](expr: T): Expr[T]
Use
reify
to produce the abstract syntax tree representing a given Scala expression.Use
reify
to produce the abstract syntax tree representing a given Scala expression.For example:
val five = reify{ 5 } // Literal(Constant(5)) reify{ 5.toString } // Apply(Select(Literal(Constant(5)), TermName("toString")), List()) reify{ five.splice.toString } // Apply(Select(five, TermName("toString")), List())
The produced tree is path dependent on the Universe
reify
was called from.Use scala.reflect.api.Exprs#Expr.splice to embed an existing expression into a
reify
call. Use Expr to turn a Tree into an expression that can be spliced.- Definition Classes
- Universe
-
def
render(what: Any, mkPrinter: (PrintWriter) ⇒ TreePrinter, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printOwners: BooleanFlag = None, printKinds: BooleanFlag = None, printMirrors: BooleanFlag = None, printPositions: BooleanFlag = None): String
- Attributes
- protected
- Definition Classes
- Printers
-
def
show(any: Any, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printOwners: BooleanFlag = None, printKinds: BooleanFlag = None, printMirrors: BooleanFlag = None, printPositions: BooleanFlag = None): String
Renders a representation of a reflection artifact as desugared Scala code.
Renders a representation of a reflection artifact as desugared Scala code.
- Definition Classes
- Printers
-
def
showCode(tree: Tree, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printOwners: BooleanFlag = None, printPositions: BooleanFlag = None, printRootPkg: Boolean = false): String
Renders the code of the passed tree, so that: 1) it can be later compiled by scalac retaining the same meaning, 2) it looks pretty.
Renders the code of the passed tree, so that: 1) it can be later compiled by scalac retaining the same meaning, 2) it looks pretty. #1 is available for unattributed trees and attributed trees #2 is more or less okay indentation-wise, but at the moment there's a lot of desugaring left in place, and that's what we plan to improve in the future. printTypes, printIds, printPositions options have the same meaning as for TreePrinter printRootPkg option is available only for attributed trees.
- Definition Classes
- Printers
-
def
showRaw(position: Position): String
Renders internal structure of a position.
Renders internal structure of a position.
- Definition Classes
- Printers
-
def
showRaw(flags: FlagSet): String
Renders internal structure of a flag set.
Renders internal structure of a flag set.
- Definition Classes
- Printers
-
def
showRaw(name: Name): String
Renders internal structure of a name.
Renders internal structure of a name.
- Definition Classes
- Printers
-
def
showRaw(any: Any, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printOwners: BooleanFlag = None, printKinds: BooleanFlag = None, printMirrors: BooleanFlag = None, printPositions: BooleanFlag = None): String
Renders internal structure of a reflection artifact as the visualization of a Scala syntax tree.
Renders internal structure of a reflection artifact as the visualization of a Scala syntax tree.
- Definition Classes
- Printers
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
val
treeCopy: TreeCopier
The standard (lazy) tree copier.
The standard (lazy) tree copier.
- Definition Classes
- Trees
-
def
treeToString(tree: Tree): String
By default trees are printed with
show
By default trees are printed with
show
- Attributes
- protected
- Definition Classes
- Printers
-
def
typeOf[T](implicit ttag: TypeTag[T]): Type
Shortcut for
implicitly[TypeTag[T]].tpe
Shortcut for
implicitly[TypeTag[T]].tpe
- Definition Classes
- TypeTags
-
def
typeTag[T](implicit ttag: TypeTag[T]): TypeTag[T]
Shortcut for
implicitly[TypeTag[T]]
Shortcut for
implicitly[TypeTag[T]]
- Definition Classes
- TypeTags
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
def
weakTypeOf[T](implicit attag: WeakTypeTag[T]): Type
Shortcut for
implicitly[WeakTypeTag[T]].tpe
Shortcut for
implicitly[WeakTypeTag[T]].tpe
- Definition Classes
- TypeTags
-
def
weakTypeTag[T](implicit attag: WeakTypeTag[T]): WeakTypeTag[T]
Shortcut for
implicitly[WeakTypeTag[T]]
Shortcut for
implicitly[WeakTypeTag[T]]
- Definition Classes
- TypeTags
-
def
xtransform(transformer: Transformer, tree: Tree): Tree
Provides an extension hook for the transformation strategy.
Provides an extension hook for the transformation strategy. Future-proofs against new node types.
- Attributes
- protected
- Definition Classes
- Trees
-
def
xtraverse(traverser: Traverser, tree: Tree): Unit
Provides an extension hook for the traversal strategy.
Provides an extension hook for the traversal strategy. Future-proofs against new node types.
- Attributes
- protected
- Definition Classes
- Trees
-
def
→[B](y: B): (JavaUniverse, B)
- Implicit
- This member is added by an implicit conversion from JavaUniverse to ArrowAssoc[JavaUniverse] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
-
object
Liftable extends Universe.StandardLiftableInstances
Companion to
Liftable
type class that contains standard instances and provides a helperapply
method to simplify creation of new ones.Companion to
Liftable
type class that contains standard instances and provides a helperapply
method to simplify creation of new ones.- Definition Classes
- Liftables
-
object
Unliftable extends Universe.StandardUnliftableInstances
Companion to
Unliftable
type class that contains standard instances and provides a helperapply
method to simplify creation of new ones.Companion to
Unliftable
type class that contains standard instances and provides a helperapply
method to simplify creation of new ones.- Definition Classes
- Liftables
-
object
BooleanFlag extends Serializable
- Definition Classes
- Printers
-
object
TypeTag extends Serializable
Type tags corresponding to primitive types and constructor/extractor for WeakTypeTags.
Type tags corresponding to primitive types and constructor/extractor for WeakTypeTags.
- Definition Classes
- TypeTags
-
object
WeakTypeTag extends Serializable
Type tags corresponding to primitive types and constructor/extractor for WeakTypeTags.
Type tags corresponding to primitive types and constructor/extractor for WeakTypeTags.
- Definition Classes
- TypeTags
Deprecated Value Members
-
def
mkImporter(from0: Universe): Importer { val from: from0.type }
- Definition Classes
- Internals
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
internal.createImporter
instead
-
implicit
def
stringToTermName(s: String): TermName
An implicit conversion from String to TermName.
An implicit conversion from String to TermName. Enables an alternative notation
"map": TermName
as opposed toTermName("map")
.- Definition Classes
- Names
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use explicit
TermName(s)
instead
-
implicit
def
stringToTypeName(s: String): TypeName
An implicit conversion from String to TypeName.
An implicit conversion from String to TypeName. Enables an alternative notation
"List": TypeName
as opposed toTypeName("List")
.- Definition Classes
- Names
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use explicit
TypeName(s)
instead
Inherited from Universe
Inherited from Internals
Inherited from Quasiquotes
Inherited from Liftables
Inherited from Printers
Inherited from Mirrors
Inherited from StandardLiftables
Inherited from StandardNames
Inherited from StandardDefinitions
Inherited from ImplicitTags
Inherited from TypeTags
Inherited from Exprs
Inherited from Positions
Inherited from Annotations
Inherited from Constants
Inherited from Trees
Inherited from Names
Inherited from Scopes
Inherited from FlagSets
Inherited from Types
Inherited from Symbols
Inherited from AnyRef
Inherited from Any
Inherited by implicit conversion any2stringadd from JavaUniverse to any2stringadd[JavaUniverse]
Inherited by implicit conversion StringFormat from JavaUniverse to StringFormat[JavaUniverse]
Inherited by implicit conversion Ensuring from JavaUniverse to Ensuring[JavaUniverse]
Inherited by implicit conversion ArrowAssoc from JavaUniverse to ArrowAssoc[JavaUniverse]
Universe
Annotations
Constants
Definitions
Expressions
Flags
Internal
JavaMirrors
Mirrors
Names
Positions
Printers
Scopes
Standard Names
Symbols
Trees
Types - Operations
TypeTags
Types
Tree Copying
Factories
Tree Traversal and Transformation
API
The methods available for each reflection entity, without the implementation. Since the reflection entities are later overridden by runtime reflection and macros, their API counterparts guarantee a minimum set of methods that are implemented.
Extractors
Extractors provide the machinery necessary to allow pattern matching and construction of reflection entities that is similar to case classes, although the entities are only abstract types that are later overridden.