class JavaUniverse extends internal.SymbolTable with JavaUniverseForce with ReflectSetup with SymbolTable
An implementation of scala.reflect.api.Universe for runtime reflection using JVM classloaders.
Should not be instantiated directly, use scala.reflect.runtime.universe instead.
- Self Type
- JavaUniverse
- Source
- JavaUniverse.scala
- Grouped
- Alphabetic
- By Inheritance
- JavaUniverse
- SymbolTable
- ThreadLocalStorage
- Gil
- SynchronizedOps
- SynchronizedTypes
- SynchronizedSymbols
- SymbolLoaders
- JavaMirrors
- TwoWayCaches
- JavaUniverse
- ReflectSetup
- JavaUniverseForce
- SymbolTable
- Reporting
- Internals
- FreshNames
- Translations
- PrivateWithin
- ReificationSupport
- StdCreators
- StdAttachments
- CapturedVariables
- Importers
- TypeDebugging
- Positions
- Printers
- Trees
- AnnotationCheckers
- AnnotationInfos
- StdNames
- Transforms
- InfoTransformers
- BaseTypeSeqs
- Constants
- Definitions
- Mirrors
- Scopes
- FlagSets
- ExistentialsAndSkolems
- Kinds
- Variances
- Types
- FindMembers
- TypeConstraints
- TypeMaps
- GlbLubs
- CommonOwners
- TypeToStrings
- TypeComparers
- Symbols
- Names
- Collections
- Universe
- 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
Instance Constructors
- new JavaUniverse()
Type Members
- 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 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
- 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 FreeTermSymbolApi extends Universe.TermSymbolApi
The API of free term symbols.
- 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
- 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
- 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
- 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
- trait MemberScopeApi extends Universe.ScopeApi
The API that all member scopes support
The API that all member scopes support
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- trait GenericApplyApi extends Universe.TermTreeApi
The API that all applies support
The API that all applies support
- 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
- 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
- trait ImplDefApi extends Universe.MemberDefApi
The API that all impl defs support
The API that all impl defs support
- 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.{w => _, x, y => z, _}
Would be represented as:
Import(qual, List(("w", WILDCARD), ("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
- 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
- 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
- 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
- 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
- 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
- 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
- trait NameTreeApi extends Universe.TreeApi
The API that all name trees support
The API that all name trees support
- Definition Classes
- Trees
- trait NamedArgApi extends Universe.TermTreeApi
The API that all assigns support
The API that all assigns support
- Definition Classes
- Trees
- abstract class NamedArgExtractor extends AnyRef
An extractor class to create and pattern match with syntax
NamedArg(lhs, rhs)
.An extractor class to create and pattern match with syntax
NamedArg(lhs, rhs)
. This AST node corresponds to the following Scala code:m.f(lhs = rhs)
@annotation(lhs = rhs)
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- trait SymTreeApi extends Universe.TreeApi
The API that all sym trees support
The API that all sym trees support
- 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
- trait TermTreeApi extends Universe.TreeApi
The API that all term trees support
The API that all term trees support
- 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
- 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
- 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 class TreeCopierOps extends AnyRef
The API of a tree copier.
The API of a tree copier.
- 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
- trait TypTreeApi extends Universe.TreeApi
The API that all typ trees support
The API that all typ trees support
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- trait CompoundTypeApi extends AnyRef
Has no special methods.
Has no special methods. Is here to provides erased identity for
CompoundType
.- 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
- 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
- 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
- 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
- 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
- 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
- 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
- trait SingletonTypeApi extends AnyRef
Has no special methods.
Has no special methods. Is here to provides erased identity for
SingletonType
.- 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
SuperType(thistpe, supertpe)
An extractor class to create and pattern match with syntax
SuperType(thistpe, supertpe)
- 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 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
- 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
- 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
- trait MacroInternalApi extends InternalApi
<invalid inheritdoc annotation>
<invalid inheritdoc annotation>
- Definition Classes
- Universe
- trait TreeGen extends AnyRef
- Definition Classes
- Universe
- trait AbstractTypeRef extends internal.SymbolTable.TypeRef with internal.SymbolTable.NonClassTypeRef
- Definition Classes
- Types
- class AbstractTypeSymbol extends internal.SymbolTable.TypeSymbol
Let's say you have a type definition
Let's say you have a type definition
type T <: Number
and tsym is the symbol corresponding to T. Then
tsym is an instance of AbstractTypeSymbol tsym.info == TypeBounds(Nothing, Number) tsym.tpe == TypeRef(NoPrefix, T, List())
- Definition Classes
- Symbols
- trait AliasTypeRef extends internal.SymbolTable.TypeRef with internal.SymbolTable.NonClassTypeRef
- Definition Classes
- Types
- class AliasTypeSymbol extends internal.SymbolTable.TypeSymbol
- Definition Classes
- Symbols
- case class Alternative extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.AlternativeApi with Product with Serializable
- Definition Classes
- Trees
- trait Annotatable[Self] extends AnyRef
- Definition Classes
- AnnotationInfos
- case class Annotated extends internal.SymbolTable.Tree with internal.SymbolTable.AnnotatedApi with Product with Serializable
- Definition Classes
- Trees
- case class AnnotatedType extends internal.SymbolTable.Type with internal.SymbolTable.RewrappingTypeProxy with internal.SymbolTable.AnnotatedTypeApi with Product with Serializable
A type carrying some annotations.
A type carrying some annotations. Created by the typechecker when eliminating Annotated trees (see typedAnnotated).
- Definition Classes
- Types
- trait AnnotationChecker extends AnyRef
An additional checker for annotations on types.
An additional checker for annotations on types. Typically these are registered by compiler plugins with the addAnnotationChecker method.
- Definition Classes
- AnnotationCheckers
- trait AnnotationFilter extends internal.SymbolTable.TypeMap
- Definition Classes
- TypeMaps
- abstract class AnnotationInfo extends internal.SymbolTable.AnnotationApi
Typed information about an annotation.
Typed information about an annotation. It can be attached to either a symbol or an annotated type.
Annotations are written to the classfile as Java annotations if
atp
conforms toClassfileAnnotation
(the classfile parser adds this interface to any Java annotation class).Annotations are pickled (written to scala symtab attribute in the classfile) if
atp
inherits formStaticAnnotation
.args
stores arguments to Scala annotations, represented as typed trees. Note that these trees are not transformed by any phases following the type-checker.assocs
stores arguments to classfile annotations as name-value pairs.- Definition Classes
- AnnotationInfos
- case class AntiPolyType extends internal.SymbolTable.Type with Product with Serializable
A class remembering a type instantiation for some a set of overloaded polymorphic symbols.
A class remembering a type instantiation for some a set of overloaded polymorphic symbols. Not used after phase
typer
.- Definition Classes
- Types
- case class AppliedTypeTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTree with internal.SymbolTable.AppliedTypeTreeApi with Product with Serializable
- Definition Classes
- Trees
- class AppliedTypeVar extends internal.SymbolTable.TypeVar
Precondition:
params.length == typeArgs.length > 0
(enforced structurally).Precondition:
params.length == typeArgs.length > 0
(enforced structurally).- Definition Classes
- Types
- case class Apply extends internal.SymbolTable.GenericApply with internal.SymbolTable.ApplyApi with Product with Serializable
- Definition Classes
- Trees
- case class ApplyDynamic extends internal.SymbolTable.SymTree with internal.SymbolTable.TermTree with Product with Serializable
- Definition Classes
- Trees
- class ApplyImplicitView extends internal.SymbolTable.Apply
- Definition Classes
- Trees
- class ApplyToImplicitArgs extends internal.SymbolTable.Apply
- Definition Classes
- Trees
- class ArgsTypeRef extends internal.SymbolTable.TypeRef
- Definition Classes
- Types
- case class ArrayAnnotArg extends internal.SymbolTable.ClassfileAnnotArg with Product with Serializable
Represents an array of classfile annotation arguments
Represents an array of classfile annotation arguments
- Definition Classes
- AnnotationInfos
- case class ArrayValue extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with Product with Serializable
An array of expressions.
An array of expressions. This AST node needs to be translated in backend. It is used to pass arguments to vararg arguments. Introduced by compiler phase uncurry.
This AST node does not have direct correspondence to Scala code, and is used to pass arguments to vararg arguments. For instance:
printf("%s%d", foo, 42)
Is translated to after compiler phase uncurry to:
Apply( Ident("printf"), Literal("%s%d"), ArrayValue(<Any>, List(Ident("foo"), Literal(42))))
- Definition Classes
- Trees
- class AsSeenFromMap extends internal.SymbolTable.TypeMap with internal.SymbolTable.KeepOnlyTypeConstraints
A map to compute the asSeenFrom method.
A map to compute the asSeenFrom method.
- Definition Classes
- TypeMaps
- case class Assign extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.AssignApi with Product with Serializable
- Definition Classes
- Trees
- trait Attachable extends AnyRef
Common code between reflect-internal Symbol and Tree related to Attachments.
Common code between reflect-internal Symbol and Tree related to Attachments.
- Definition Classes
- StdAttachments
- class BaseTypeSeq extends AnyRef
Note: constructor is protected to force everyone to use the factory method newBaseTypeSeq instead.
Note: constructor is protected to force everyone to use the factory method newBaseTypeSeq instead. This is necessary because when run from reflection every base type sequence needs to have a SynchronizedBaseTypeSeq as mixin.
- Definition Classes
- BaseTypeSeqs
- case class Bind extends internal.SymbolTable.DefTree with internal.SymbolTable.BindApi with Product with Serializable
- Definition Classes
- Trees
- case class Block extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.BlockApi with Product with Serializable
- Definition Classes
- Trees
- case class BoundedWildcardType extends internal.SymbolTable.ProtoType with internal.SymbolTable.BoundedWildcardTypeApi with Product with Serializable
BoundedWildcardTypes, used only during type inference, are created in two places that I can find:
BoundedWildcardTypes, used only during type inference, are created in two places that I can find:
- 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 CannotHaveAttrs extends internal.SymbolTable.Tree
- Definition Classes
- Trees
- case class CaseDef extends internal.SymbolTable.Tree with internal.SymbolTable.CaseDefApi with Product with Serializable
- Definition Classes
- Trees
- class ChangeOwnerTraverser extends internal.SymbolTable.InternalTraverser
- Definition Classes
- Trees
- abstract class ChildSolidDescendantsCollector extends internal.SymbolTable.Traverser
- Definition Classes
- Positions
- case class ClassDef extends internal.SymbolTable.ImplDef with internal.SymbolTable.ClassDefApi with Product with Serializable
- Definition Classes
- Trees
- case class ClassInfoType extends internal.SymbolTable.CompoundType with internal.SymbolTable.ClassInfoTypeApi with Product with Serializable
A class representing a class info
A class representing a class info
- Definition Classes
- Types
- class ClassSymbol extends internal.SymbolTable.TypeSymbol with internal.SymbolTable.ClassSymbolApi
A class for class symbols
A class for class symbols
- Definition Classes
- Symbols
- class ClassUnwrapper extends internal.SymbolTable.TypeUnwrapper
- Definition Classes
- Types
- sealed abstract class ClassfileAnnotArg extends Product with internal.SymbolTable.JavaArgumentApi
Arguments to constant annotations (Annotations defined in Java or extending ConstantAnnotation).
Arguments to constant annotations (Annotations defined in Java or extending ConstantAnnotation). Arguments are either:
- constants
- arrays of constants
- or nested classfile annotations (only for Java annotation)
TODO: rename to
ConstantAnnotationArg
- Definition Classes
- AnnotationInfos
- class CodePrinter extends internal.SymbolTable.TreePrinter
- Definition Classes
- Printers
- class CollectTreeTraverser[T] extends internal.SymbolTable.InternalTraverser
- Definition Classes
- Trees
- class CollectTypeCollector[T] extends internal.SymbolTable.TypeCollector[List[T]]
A map to implement the
collect
method.A map to implement the
collect
method.- Definition Classes
- TypeMaps
- abstract class CommonNames extends internal.SymbolTable.NamesApi
- Definition Classes
- StdNames
- class CommonOwnerMap extends internal.SymbolTable.TypeCollector[internal.SymbolTable.Symbol]
- Attributes
- protected
- Definition Classes
- CommonOwners
- class CompleteAnnotationInfo extends internal.SymbolTable.AnnotationInfo
- Definition Classes
- AnnotationInfos
- abstract class CompoundType extends internal.SymbolTable.Type with internal.SymbolTable.CompoundTypeApi
A common base class for intersection types and class types
A common base class for intersection types and class types
- Definition Classes
- Types
- case class CompoundTypeTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTree with internal.SymbolTable.CompoundTypeTreeApi with Product with Serializable
- Definition Classes
- Trees
- case class CompoundTypeTreeOriginalAttachment extends Product with Serializable
Stores the trees that give rise to a refined type to be used in reification.
Stores the trees that give rise to a refined type to be used in reification. Unfortunately typed
CompoundTypeTree
is lacking essential info, and the reifier cannot useCompoundTypeTree.tpe
. Therefore we need this hack (seeReshape.toPreTyperTypeTree
for a detailed explanation).- Definition Classes
- StdAttachments
- case class Constant extends internal.SymbolTable.ConstantApi with Product with Serializable
- Definition Classes
- Constants
- abstract class ConstantType extends internal.SymbolTable.SingletonType with internal.SymbolTable.ConstantTypeApi
A class representing a constant type.
A class representing a constant type. A constant type is either the inferred type of a constant value or an explicit or inferred literal type. Both may be constant folded at the type level, however literal types are not folded at the term level and do not elide effects.
- Definition Classes
- Types
- class ContainsAnyCollector extends internal.SymbolTable.ExistsTypeRefCollector
- Definition Classes
- TypeMaps
- class ContainsAnyKeyCollector extends internal.SymbolTable.ExistsTypeRefCollector
- Definition Classes
- TypeMaps
- class ContainsCollector extends internal.SymbolTable.ExistsTypeRefCollector
A map to implement the
contains
method.A map to implement the
contains
method.- Definition Classes
- TypeMaps
- case class CyclicReference extends internal.SymbolTable.TypeError with Product with Serializable
An exception for cyclic references of symbol definitions
An exception for cyclic references of symbol definitions
- Definition Classes
- Symbols
- case class DefDef extends internal.SymbolTable.ValOrDefDef with internal.SymbolTable.DefDefApi with Product with Serializable
- Definition Classes
- Trees
- abstract class DefTree extends internal.SymbolTable.SymTree with internal.SymbolTable.NameTree with internal.SymbolTable.DefTreeApi
- Definition Classes
- Trees
- class DefaultPosAssigner extends internal.SymbolTable.InternalTraverser with internal.SymbolTable.PosAssigner
- Attributes
- protected
- Definition Classes
- Positions
- abstract class DefinitionsClass extends internal.SymbolTable.DefinitionsApi with internal.SymbolTable.ValueClassDefinitions
- Definition Classes
- Definitions
- abstract case class ErasedValueType extends internal.SymbolTable.UniqueType with Product with Serializable
A temporary type representing the erasure of a user-defined value type.
A temporary type representing the erasure of a user-defined value type. Created during phase erasure, eliminated again in posterasure.
scala/bug#6385 Erasure's creation of bridges considers method signatures
exitingErasure
, which containErasedValueType
-s. In order to correctly consider the overriding and overridden signatures as equivalent inrun/t6385.scala
, it is critical that this type contains the erasure of the wrapped type, rather than the unerased type of the value class itself, as was originally done.- Definition Classes
- Types
- class ErroneousAnnotation extends internal.SymbolTable.CompleteAnnotationInfo
- Definition Classes
- AnnotationInfos
- class ErrorScope extends internal.SymbolTable.Scope
The error scope.
The error scope.
- Definition Classes
- Scopes
- class ExistentialExtrapolation extends internal.SymbolTable.VariancedTypeMap
Used by existentialAbstraction.
Used by existentialAbstraction.
- Definition Classes
- TypeMaps
- case class ExistentialType extends internal.SymbolTable.Type with internal.SymbolTable.RewrappingTypeProxy with internal.SymbolTable.ExistentialTypeApi with Product with Serializable
- Definition Classes
- Types
- case class ExistentialTypeTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTree with internal.SymbolTable.ExistentialTypeTreeApi with Product with Serializable
- Definition Classes
- Trees
- abstract class ExistsTypeRefCollector extends internal.SymbolTable.TypeCollector[Boolean]
- Definition Classes
- TypeMaps
- class FilterTreeTraverser extends internal.SymbolTable.InternalTraverser
- Definition Classes
- Trees
- class FilterTypeCollector extends internal.SymbolTable.TypeCollector[List[internal.SymbolTable.Type]]
A map to implement the
filter
method.A map to implement the
filter
method.- Definition Classes
- TypeMaps
- class FindTreeTraverser extends internal.SymbolTable.InternalTraverser
- Definition Classes
- Trees
- class FindTypeCollector extends internal.SymbolTable.TypeCollector[Option[internal.SymbolTable.Type]]
A map to implement the
filter
method.A map to implement the
filter
method.- Definition Classes
- TypeMaps
- case class FixedMirrorTreeCreator extends TreeCreator with Product with Serializable
- Definition Classes
- StdCreators
- case class FixedMirrorTypeCreator extends TypeCreator with Product with Serializable
- Definition Classes
- StdCreators
- trait FlagAgnosticCompleter extends internal.SymbolTable.LazyType
A marker trait representing an as-yet unevaluated type which doesn't assign flags to the underlying symbol.
A marker trait representing an as-yet unevaluated type which doesn't assign flags to the underlying symbol.
- Definition Classes
- Types
- trait FlagAssigningCompleter extends internal.SymbolTable.LazyType
A marker trait representing an as-yet unevaluated type which assigns flags to the underlying symbol.
A marker trait representing an as-yet unevaluated type which assigns flags to the underlying symbol.
- Definition Classes
- Types
- abstract case class FoldableConstantType extends internal.SymbolTable.ConstantType with Product with Serializable
A class representing the inferred type of a constant value.
A class representing the inferred type of a constant value. Constant types and their corresponding terms are constant-folded during type checking. To avoid constant folding, use the type returned by
deconst
instead.- Definition Classes
- Types
- class ForEachTypeTraverser extends internal.SymbolTable.TypeTraverser
- Definition Classes
- TypeMaps
- class ForeachPartialTreeTraverser extends internal.SymbolTable.InternalTraverser
- Definition Classes
- Trees
- class ForeachTreeTraverser extends internal.SymbolTable.InternalTraverser
- Definition Classes
- Trees
- trait FreeSymbol extends internal.SymbolTable.Symbol
- Definition Classes
- Symbols
- class FreeTermSymbol extends internal.SymbolTable.TermSymbol with internal.SymbolTable.FreeSymbol with internal.SymbolTable.FreeTermSymbolApi
- Definition Classes
- Symbols
- class FreeTypeSymbol extends internal.SymbolTable.TypeSkolem with internal.SymbolTable.FreeSymbol with internal.SymbolTable.FreeTypeSymbolApi
- Definition Classes
- Symbols
- class FreshNameExtractor extends AnyRef
- Definition Classes
- FreshNames
- case class Function extends internal.SymbolTable.SymTree with internal.SymbolTable.TermTree with internal.SymbolTable.FunctionApi with Product with Serializable
- Definition Classes
- Trees
- abstract class GenericApply extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.GenericApplyApi
- Definition Classes
- Trees
- class HKTypeVar extends internal.SymbolTable.TypeVar
Precondition: !params.isEmpty.
Precondition: !params.isEmpty. (args.nonEmpty enforced structurally.)
- Definition Classes
- Types
- case class Ident extends internal.SymbolTable.SymTree with internal.SymbolTable.RefTree with internal.SymbolTable.IdentApi with Product with Serializable
- Definition Classes
- Trees
- case class If extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.IfApi with Product with Serializable
- Definition Classes
- Trees
- abstract class ImplDef extends internal.SymbolTable.MemberDef with internal.SymbolTable.ImplDefApi
- Definition Classes
- Trees
- case class Import extends internal.SymbolTable.SymTree with internal.SymbolTable.ImportApi with Product with Serializable
- Definition Classes
- Trees
- case class ImportSelector extends internal.SymbolTable.ImportSelectorApi with Product with Serializable
- Definition Classes
- Trees
- case class ImportType extends internal.SymbolTable.Type with Product with Serializable
- Definition Classes
- Types
- trait ImportableAttachment extends AnyRef
Attachment that knows how to import itself into another universe.
Attachment that knows how to import itself into another universe.
- Definition Classes
- StdAttachments
- abstract class InfoTransformer extends AnyRef
- Definition Classes
- InfoTransformers
- abstract class InlineAnnotatedAttachment extends AnyRef
- Definition Classes
- StdAttachments
- class InstantiateDependentMap extends internal.SymbolTable.TypeMap with internal.SymbolTable.KeepOnlyTypeConstraints
Note: This map is needed even for non-dependent method types, despite what the name might imply.
Note: This map is needed even for non-dependent method types, despite what the name might imply.
- Definition Classes
- TypeMaps
- type Internal = MacroInternalApi
- Definition Classes
- Internals → Internals
- See also
- class InternalTransformer extends internal.SymbolTable.Transformer
- Definition Classes
- Trees
- class InternalTraverser extends internal.SymbolTable.Traverser
- Definition Classes
- Trees
- abstract class InternalTreeCopierOps extends internal.SymbolTable.TreeCopierOps
- Definition Classes
- Trees
- trait JavaClassCompleter extends AnyRef
- Definition Classes
- JavaMirrors
- class JavaKeywords extends AnyRef
- Definition Classes
- StdNames
- class JavaMirror extends SymbolTable.Roots with SymbolTable.JavaMirror
The API of a mirror for a reflective universe
The API of a mirror for a reflective universe
- Definition Classes
- JavaMirrors
- trait KeepOnlyTypeConstraints extends internal.SymbolTable.TypeMap with internal.SymbolTable.AnnotationFilter
- Definition Classes
- TypeMaps
- abstract class Keywords extends internal.SymbolTable.CommonNames
This should be the first trait in the linearization.
This should be the first trait in the linearization.
- Definition Classes
- StdNames
- abstract class Kind extends AnyRef
The data structure describing the kind of a given type.
The data structure describing the kind of a given type.
Proper types are represented using ProperTypeKind.
Type constructors are represented using TypeConKind.
- Definition Classes
- Kinds
- case class KindErrors extends Product with Serializable
- Definition Classes
- Kinds
- case class LabelDef extends internal.SymbolTable.DefTree with internal.SymbolTable.TermTree with internal.SymbolTable.LabelDefApi with Product with Serializable
- Definition Classes
- Trees
- final class LazyAnnotationInfo extends internal.SymbolTable.AnnotationInfo
Symbol annotations parsed in
Namer
(typeCompleter of definitions) have to be lazy (#1782)Symbol annotations parsed in
Namer
(typeCompleter of definitions) have to be lazy (#1782)- Definition Classes
- AnnotationInfos
- class LazyPackageType extends SymbolTable.LazyType with SymbolTable.FlagAgnosticCompleter
The type completer for packages.
The type completer for packages.
- Definition Classes
- SymbolLoaders
- abstract class LazyPolyType extends internal.SymbolTable.LazyType
- Definition Classes
- Types
- class LazyTreeCopier extends internal.SymbolTable.InternalTreeCopierOps
- Definition Classes
- Trees
- abstract class LazyType extends internal.SymbolTable.Type
A class representing an as-yet unevaluated type.
A class representing an as-yet unevaluated type.
- Definition Classes
- Types
- case class Literal extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.LiteralApi with Product with Serializable
- Definition Classes
- Trees
- case class LiteralAnnotArg extends internal.SymbolTable.ClassfileAnnotArg with Product with Serializable
Represents a compile-time Constant (
Boolean
,Byte
,Short
,Char
,Int
,Long
,Float
,Double
,String
,java.lang.Class
or an instance of a Java enumeration value).Represents a compile-time Constant (
Boolean
,Byte
,Short
,Char
,Int
,Long
,Float
,Double
,String
,java.lang.Class
or an instance of a Java enumeration value).- Definition Classes
- AnnotationInfos
- abstract case class LiteralType extends internal.SymbolTable.ConstantType with Product with Serializable
A class representing an explicit or inferred literal type.
A class representing an explicit or inferred literal type. Literal types may be be folded at at the type level during type checking, however they will not be folded at the term level and effects will not be elided.
- Definition Classes
- Types
- class LocalOwnersTraverser extends internal.SymbolTable.InternalTraverser
- Definition Classes
- Trees
- class Locator extends internal.SymbolTable.Traverser
A locator for trees with given positions.
A locator for trees with given positions. Given a position
pos
, locator.apply returns the smallest tree that enclosespos
.- Definition Classes
- Positions
- case class LookupAmbiguous extends internal.SymbolTable.NameLookup with Product with Serializable
- Definition Classes
- Scopes
- case class LookupInaccessible extends internal.SymbolTable.NameLookup with Product with Serializable
- Definition Classes
- Scopes
- case class LookupSucceeded extends internal.SymbolTable.NameLookup with Product with Serializable
- Definition Classes
- Scopes
- class MalformedType extends internal.SymbolTable.TypeError
A throwable signalling a malformed type
A throwable signalling a malformed type
- Definition Classes
- Types
- class MappedBaseTypeSeq extends internal.SymbolTable.BaseTypeSeq
- Definition Classes
- BaseTypeSeqs
- case class Match extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.MatchApi with Product with Serializable
- Definition Classes
- Trees
- abstract class MemberDef extends internal.SymbolTable.DefTree with internal.SymbolTable.MemberDefApi
- Definition Classes
- Trees
- class MethodSymbol extends internal.SymbolTable.TermSymbol with internal.SymbolTable.MethodSymbolApi
A class for method symbols
A class for method symbols
- Definition Classes
- Symbols
- case class MethodType extends internal.SymbolTable.Type with internal.SymbolTable.MethodTypeApi with Product with Serializable
A class representing a method type with parameters.
A class representing a method type with parameters. Note that a parameterless method is represented by a NullaryMethodType:
def m(): Int MethodType(Nil, Int) def m: Int NullaryMethodType(Int)
- Definition Classes
- Types
- type Mirror = JavaMirror
In runtime reflection universes, mirrors are
JavaMirrors
.In runtime reflection universes, mirrors are
JavaMirrors
.- Definition Classes
- JavaMirrors → JavaUniverse → Mirrors → Mirrors
- class MissingAliasControl extends ControlThrowable
- Definition Classes
- Types
- class MissingTypeControl extends ControlThrowable
- Definition Classes
- Types
- case class Modifiers extends internal.SymbolTable.ModifiersApi with HasFlags with Product with Serializable
- Definition Classes
- Trees
- class ModuleClassSymbol extends internal.SymbolTable.ClassSymbol
A class for module class symbols Note: Not all module classes are of this type; when unpickled, we get plain class symbols!
A class for module class symbols Note: Not all module classes are of this type; when unpickled, we get plain class symbols!
- Definition Classes
- Symbols
- case class ModuleDef extends internal.SymbolTable.ImplDef with internal.SymbolTable.ModuleDefApi with Product with Serializable
- Definition Classes
- Trees
- class ModuleSymbol extends internal.SymbolTable.TermSymbol with internal.SymbolTable.ModuleSymbolApi
A class for module symbols
A class for module symbols
- Definition Classes
- Symbols
- class ModuleTypeRef extends internal.SymbolTable.NoArgsTypeRef
- Definition Classes
- Types
- sealed abstract class Name extends internal.Names.NameApi with CharSequence
The name class.
The name class. TODO - resolve schizophrenia regarding whether to treat Names as Strings or Strings as Names. Give names the key functions the absence of which make people want Strings all the time.
- Definition Classes
- Names
- sealed trait NameLookup extends AnyRef
An ADT to represent the results of symbol name lookups.
An ADT to represent the results of symbol name lookups.
- Definition Classes
- Scopes
- final class NameOps[T <: Name] extends AnyRef
FIXME: This is a good example of something which is pure "value class" but cannot reap the benefits because an (unused) $outer pointer so it is not single-field.
FIXME: This is a good example of something which is pure "value class" but cannot reap the benefits because an (unused) $outer pointer so it is not single-field.
- Definition Classes
- Names
- trait NameTree extends internal.SymbolTable.Tree with internal.SymbolTable.NameTreeApi
- Definition Classes
- Trees
- case class NamedArg extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.NamedArgApi with Product with Serializable
- Definition Classes
- Trees
- case class NamedType extends internal.SymbolTable.Type with Product with Serializable
A class representing types with a name.
A class representing types with a name. When an application uses named arguments, the named argument types for calling isApplicable are represented as NamedType.
- Definition Classes
- Types
- case class NestedAnnotArg extends internal.SymbolTable.ClassfileAnnotArg with Product with Serializable
Represents a nested classfile annotation
Represents a nested classfile annotation
- Definition Classes
- AnnotationInfos
- case class New extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.NewApi with Product with Serializable
- Definition Classes
- Trees
- class NoArgsTypeRef extends internal.SymbolTable.TypeRef
- Definition Classes
- Types
- class NoCommonType extends ControlThrowable
- Definition Classes
- Types
- class NoSymbol extends internal.SymbolTable.Symbol
An object representing a missing symbol
An object representing a missing symbol
- Definition Classes
- Symbols
- trait NonClassTypeRef extends internal.SymbolTable.TypeRef
- Definition Classes
- Types
- case class NullaryMethodType extends internal.SymbolTable.Type with internal.SymbolTable.NullaryMethodTypeApi with Product with Serializable
- Definition Classes
- Types
- final case class OverloadedArgProto extends internal.SymbolTable.ProtoType with internal.SymbolTable.SimpleTypeProxy with Product with Serializable
Lazily compute expected types for arguments to overloaded methods.
Lazily compute expected types for arguments to overloaded methods. Primarily to improve parameter type inference for higher-order overloaded methods.
Normally, overload resolution types the arguments to the alternatives without an expected type. However, typing function literals and eta-expansion are driven by the expected type:
- function literals usually don't have parameter types, which are derived from the expected type;
- eta-expansion right now only happens when a function/sam type is expected.
Now that the collections are full of overloaded HO methods, we should try harder to type check them nicely.
(This paragraph is conceptually true, but not a spec.) To avoid breaking existing code, we only provide an expected type (for each argument position) when:
- there is at least one FunctionN type expected by one of the overloads: in this case, the expected type is a FunctionN[Ti, ?], where Ti are the argument types (they must all be =:=), and the expected result type is elided using a wildcard. This does not exclude any overloads that expect a SAM, because they conform to a function type through SAM conversion
- OR: all overloads expect a SAM type of the same class, but with potentially varying result types (argument types must be =:=)
- OR: all expected types collapse to the same type (by =:=, pushing down method type params to arguments types)
We allow polymorphic cases, taking account any instantiation by the AntiPolyType prefix. Constructors of polymorphic classes are not supported (type param occurrences use fresh symbols, hard to relate to class's type params).
In all other cases, the old behavior is maintained: Wildcard is expected.
- Definition Classes
- Types
- case class OverloadedType extends internal.SymbolTable.Type with Product with Serializable
A class containing the alternatives and type prefix of an overloaded symbol.
A class containing the alternatives and type prefix of an overloaded symbol. Not used after phase
typer
.- Definition Classes
- Types
- class PackageClassInfoType extends internal.SymbolTable.ClassInfoType
- Definition Classes
- Types
- class PackageClassSymbol extends internal.SymbolTable.ModuleClassSymbol
- Definition Classes
- Symbols
- case class PackageDef extends internal.SymbolTable.MemberDef with internal.SymbolTable.PackageDefApi with Product with Serializable
- Definition Classes
- Trees
- class PackageObjectClassSymbol extends internal.SymbolTable.ModuleClassSymbol
- Definition Classes
- Symbols
- class PackageScope extends SymbolTable.Scope with SymbolTable.SynchronizedScope
- Definition Classes
- SymbolLoaders
- class PackageTypeRef extends internal.SymbolTable.ModuleTypeRef
- Definition Classes
- Types
- class PerRunReporting extends PerRunReportingBase
- abstract class PerRunReportingBase extends AnyRef
- Definition Classes
- Reporting
- type Period = Int
A period is an ordinal number for a phase in a run.
A period is an ordinal number for a phase in a run. Phases in later runs have higher periods than phases in earlier runs. Later phases have higher periods than earlier phases in the same run.
- Definition Classes
- SymbolTable
- trait PlainAttachment extends internal.SymbolTable.ImportableAttachment
Attachment that doesn't contain any reflection artifacts and can be imported as-is.
Attachment that doesn't contain any reflection artifacts and can be imported as-is.
- Definition Classes
- StdAttachments
- case class PolyType extends internal.SymbolTable.Type with internal.SymbolTable.PolyTypeApi with Product with Serializable
A type function or the type of a polymorphic value (and thus of kind *).
A type function or the type of a polymorphic value (and thus of kind *).
Before the introduction of NullaryMethodType, a polymorphic nullary method (e.g, def isInstanceOf[T]: Boolean) used to be typed as PolyType(tps, restpe), and a monomorphic one as PolyType(Nil, restpe) This is now: PolyType(tps, NullaryMethodType(restpe)) and NullaryMethodType(restpe) by symmetry to MethodTypes: PolyType(tps, MethodType(params, restpe)) and MethodType(params, restpe)
Thus, a PolyType(tps, TypeRef(...)) unambiguously indicates a type function (which results from eta-expanding a type constructor alias). Similarly, PolyType(tps, ClassInfoType(...)) is a type constructor.
A polytype is of kind * iff its resultType is a (nullary) method type.
- Definition Classes
- Types
- trait PosAssigner extends internal.SymbolTable.InternalTraverser
- Definition Classes
- Positions
- type Position = internal.util.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 → Positions
- class ProperTypeKind extends internal.SymbolTable.Kind
- Definition Classes
- Kinds
- abstract class ProtoType extends internal.SymbolTable.Type
- Definition Classes
- Types
- class QualTypeSymAttachment extends AnyRef
- Definition Classes
- StdAttachments
- class RawTreePrinter extends internal.SymbolTable.TreePrinter
- Definition Classes
- Printers
- case class RecoverableCyclicReference extends internal.SymbolTable.TypeError with Product with Serializable
An exception for cyclic references from which we can recover
An exception for cyclic references from which we can recover
- Definition Classes
- Types
- trait RefTree extends internal.SymbolTable.SymTree with internal.SymbolTable.NameTree with internal.SymbolTable.RefTreeApi
- Definition Classes
- Trees
- case class ReferenceToBoxed extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.ReferenceToBoxedApi with Product with Serializable
- Definition Classes
- Trees
- case class RefinedType extends internal.SymbolTable.CompoundType with internal.SymbolTable.RefinedTypeApi with Product with Serializable
A class representing intersection types with refinements of the form
<parents_0> with ... with <parents_n> { decls }
Cannot be created directly; one should always userefinedType
for creation.A class representing intersection types with refinements of the form
<parents_0> with ... with <parents_n> { decls }
Cannot be created directly; one should always userefinedType
for creation.- Definition Classes
- Types
- final class RefinedType0 extends internal.SymbolTable.RefinedType
- Definition Classes
- Types
- class RefinementClassSymbol extends internal.SymbolTable.ClassSymbol
- Definition Classes
- Symbols
- class RefinementTypeRef extends internal.SymbolTable.NoArgsTypeRef
- Definition Classes
- Types
- trait ReflectStats extends BaseTypeSeqsStats with TypesStats with SymbolTableStats with TreesStats with SymbolsStats with ScopeStats
- Definition Classes
- SymbolTable
- class ReificationSupportImpl extends internal.SymbolTable.ReificationSupportApi
- Definition Classes
- ReificationSupport
- case class RepeatedType extends internal.SymbolTable.Type with Product with Serializable
As with NamedType, used only when calling isApplicable.
As with NamedType, used only when calling isApplicable. Records that the application has a wildcard star (aka _*) at the end of it.
- Definition Classes
- Types
- case class Return extends internal.SymbolTable.SymTree with internal.SymbolTable.TermTree with internal.SymbolTable.ReturnApi with Product with Serializable
- Definition Classes
- Trees
- trait RewrappingTypeProxy extends internal.SymbolTable.Type with internal.SymbolTable.SimpleTypeProxy
A proxy for a type (identified by field
underlying
) that forwards most operations to it.A proxy for a type (identified by field
underlying
) that forwards most operations to it. Every operation that is overridden for some kind of types is forwarded here. Some operations are rewrapped again.- Definition Classes
- Types
- trait RootSymbol extends internal.SymbolTable.Symbol
- Definition Classes
- Mirrors
- abstract class Roots extends internal.SymbolTable.RootsBase
- Definition Classes
- Mirrors
- abstract class RootsBase extends api.Mirror[Mirrors.this.type]
- Definition Classes
- Mirrors
- type RunId = Int
An ordinal number for compiler runs.
An ordinal number for compiler runs. First run has number 1.
- Definition Classes
- SymbolTable
- trait RunReporting extends AnyRef
- Definition Classes
- Reporting
- 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
- case class SAMFunction extends internal.SymbolTable.PlainAttachment with Product with Serializable
Attached to a Function node during type checking when the expected type is a SAM type (and not a built-in FunctionN).
Attached to a Function node during type checking when the expected type is a SAM type (and not a built-in FunctionN).
Ideally, we'd move to Dotty's Closure AST, which tracks the environment, the lifted method that has the implementation, and the target type. For backwards compatibility, an attachment is the best we can do right now.
- Definition Classes
- StdAttachments
- Since
2.12.0-M4
- class Scope extends AbstractIterable[internal.SymbolTable.Symbol] with internal.SymbolTable.ScopeApi with internal.SymbolTable.MemberScopeApi
Note: constructor is protected to force everyone to use the factory methods newScope or newNestedScope instead.
Note: constructor is protected to force everyone to use the factory methods newScope or newNestedScope instead. This is necessary because when run from reflection every scope needs to have a SynchronizedScope as mixin.
- Definition Classes
- Scopes
- class ScopeEntry extends AnyRef
- Definition Classes
- Scopes
- case class Select extends internal.SymbolTable.SymTree with internal.SymbolTable.RefTree with internal.SymbolTable.SelectApi with Product with Serializable
- Definition Classes
- Trees
- case class SelectFromTypeTree extends internal.SymbolTable.SymTree with internal.SymbolTable.RefTree with internal.SymbolTable.TypTree with internal.SymbolTable.SelectFromTypeTreeApi with Product with Serializable
- Definition Classes
- Trees
- trait SimpleTypeProxy extends internal.SymbolTable.Type
A proxy for a type (identified by field
underlying
) that forwards most operations to it (for exceptions, see WrappingProxy, which forwards even more operations).A proxy for a type (identified by field
underlying
) that forwards most operations to it (for exceptions, see WrappingProxy, which forwards even more operations). every operation that is overridden for some kind of types should be forwarded.- Definition Classes
- Types
- abstract case class SingleType extends internal.SymbolTable.SingletonType with internal.SymbolTable.SingleTypeApi with Product with Serializable
A class for singleton types of the form
<prefix>.<sym.name>.type
.A class for singleton types of the form
<prefix>.<sym.name>.type
. Cannot be created directly; one should always usesingleType
for creation.- Definition Classes
- Types
- abstract class SingletonType extends internal.SymbolTable.SubType with internal.SymbolTable.SimpleTypeProxy with internal.SymbolTable.SingletonTypeApi
A base class for types that represent a single value (single-types and this-types).
A base class for types that represent a single value (single-types and this-types).
- Definition Classes
- Types
- case class SingletonTypeTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTree with internal.SymbolTable.SingletonTypeTreeApi with Product with Serializable
- Definition Classes
- Trees
- abstract class StandardImporter extends internal.SymbolTable.Importer
- Definition Classes
- Importers
- case class Star extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.StarApi with Product with Serializable
- Definition Classes
- Trees
- class StrictTreeCopier extends internal.SymbolTable.InternalTreeCopierOps
- Definition Classes
- Trees
- class StubClassSymbol extends internal.SymbolTable.ClassSymbol with internal.SymbolTable.StubSymbol
- Definition Classes
- Symbols
- trait StubSymbol extends internal.SymbolTable.Symbol
- Definition Classes
- Symbols
- class StubTermSymbol extends internal.SymbolTable.TermSymbol with internal.SymbolTable.StubSymbol
- Definition Classes
- Symbols
- abstract class SubType extends internal.SymbolTable.UniqueType
A base class for types that defer some operations to their immediate supertype.
A base class for types that defer some operations to their immediate supertype.
- Definition Classes
- Types
- final case class SubTypePair extends Product with Serializable
- Definition Classes
- TypeComparers
- case class SubpatternsAttachment extends Product with Serializable
Untyped list of subpatterns attached to selector dummy.
Untyped list of subpatterns attached to selector dummy.
- Definition Classes
- StdAttachments
- abstract class SubstMap[T] extends internal.SymbolTable.TypeMap
A base class to compute all substitutions
A base class to compute all substitutions
- Definition Classes
- TypeMaps
- class SubstSymMap extends internal.SymbolTable.SubstMap[internal.SymbolTable.Symbol]
A map to implement the
substSym
method.A map to implement the
substSym
method.- Definition Classes
- TypeMaps
- class SubstThisMap extends internal.SymbolTable.TypeMap
A map to implement the
substThis
method.A map to implement the
substThis
method.- Definition Classes
- TypeMaps
- class SubstTypeMap extends internal.SymbolTable.SubstMap[internal.SymbolTable.Type]
A map to implement the
subst
method.A map to implement the
subst
method.- Definition Classes
- TypeMaps
- class SubstWildcardMap extends internal.SymbolTable.TypeMap
- Definition Classes
- TypeMaps
- case class Super extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.SuperApi with Product with Serializable
- Definition Classes
- Trees
- abstract case class SuperType extends internal.SymbolTable.SingletonType with internal.SymbolTable.SuperTypeApi with Product with Serializable
- Definition Classes
- Types
- abstract class SymLoader extends internal.SymbolTable.LazyType
- Definition Classes
- SymbolTable
- abstract class SymTree extends internal.SymbolTable.Tree with internal.SymbolTable.SymTreeApi
- Definition Classes
- Trees
- abstract class Symbol extends internal.SymbolTable.SymbolContextApiImpl with HasFlags with internal.SymbolTable.Annotatable[internal.SymbolTable.Symbol] with internal.SymbolTable.Attachable
The class for all symbols
The class for all symbols
- Definition Classes
- Symbols
- abstract class SymbolContextApiImpl extends internal.SymbolTable.SymbolApi
- Definition Classes
- Symbols
- sealed abstract class SymbolNames extends AnyRef
- Definition Classes
- StdNames
- case class SymbolOps extends Product with Serializable
- Definition Classes
- Symbols
- trait SymbolTableInternal extends internal.SymbolTable.MacroInternalApi
- Definition Classes
- Internals
- trait SynchronizedBaseTypeSeq extends SymbolTable.BaseTypeSeq
- Definition Classes
- SynchronizedOps
- trait SynchronizedClassSymbol extends SymbolTable.ClassSymbol with SymbolTable.SynchronizedTypeSymbol
- Definition Classes
- SynchronizedSymbols
- trait SynchronizedMethodSymbol extends SymbolTable.MethodSymbol with SymbolTable.SynchronizedTermSymbol
- Definition Classes
- SynchronizedSymbols
- trait SynchronizedModuleClassSymbol extends SymbolTable.ModuleClassSymbol with SymbolTable.SynchronizedClassSymbol
- Definition Classes
- SynchronizedSymbols
- trait SynchronizedModuleSymbol extends SymbolTable.ModuleSymbol with SymbolTable.SynchronizedTermSymbol
- Definition Classes
- SynchronizedSymbols
- trait SynchronizedScope extends SymbolTable.Scope
- Definition Classes
- SynchronizedOps
- trait SynchronizedSymbol extends SymbolTable.Symbol
- Definition Classes
- SynchronizedSymbols
- trait SynchronizedTermSymbol extends SymbolTable.Symbol with SymbolTable.SynchronizedSymbol
- Definition Classes
- SynchronizedSymbols
- trait SynchronizedTypeSymbol extends SymbolTable.TypeSymbol with SymbolTable.SynchronizedSymbol
- Definition Classes
- SynchronizedSymbols
- case class Template extends internal.SymbolTable.SymTree with internal.SymbolTable.TemplateApi with Product with Serializable
- Definition Classes
- Trees
- sealed abstract class TermName extends Name with internal.Names.TermNameApi
- Definition Classes
- Names
- abstract class TermNames extends internal.SymbolTable.Keywords with internal.SymbolTable.TermNamesApi
- Definition Classes
- StdNames
- class TermSymbol extends internal.SymbolTable.Symbol with internal.SymbolTable.TermSymbolApi
A class for term symbols
A class for term symbols
- Definition Classes
- Symbols
- trait TermTree extends internal.SymbolTable.Tree with internal.SymbolTable.TermTreeApi
- Definition Classes
- Trees
- case class This extends internal.SymbolTable.SymTree with internal.SymbolTable.TermTree with internal.SymbolTable.ThisApi with Product with Serializable
- Definition Classes
- Trees
- class ThisSubstituter extends internal.SymbolTable.InternalTransformer
Substitute clazz.this with
to
.Substitute clazz.this with
to
.to
must be an attributed tree.- Definition Classes
- Trees
- abstract case class ThisType extends internal.SymbolTable.SingletonType with internal.SymbolTable.ThisTypeApi with Product with Serializable
A class for this-types of the form <sym>.this.type
A class for this-types of the form <sym>.this.type
- Definition Classes
- Types
- trait ThreadLocalStorage[T] extends AnyRef
- Definition Classes
- ThreadLocalStorage
- case class Throw extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.ThrowApi with Product with Serializable
- Definition Classes
- Trees
- class TopClassCompleter extends SymbolTable.SymLoader with SymbolTable.FlagAssigningCompleter
The standard completer for top-level classes
The standard completer for top-level classes
- Definition Classes
- SymbolLoaders
- abstract class Tree extends internal.SymbolTable.TreeContextApiImpl with internal.SymbolTable.Attachable with Product
- Definition Classes
- Trees
- abstract class TreeContextApiImpl extends internal.SymbolTable.TreeApi
- Definition Classes
- Trees
- type TreeCopier = InternalTreeCopierOps
The type of standard (lazy) tree copiers.
The type of standard (lazy) tree copiers.
- Definition Classes
- JavaUniverse → Trees → Trees
- class TreePrinter extends internal.SymbolTable.TreePrinter
- Definition Classes
- Printers
- class TreeReplacer extends internal.SymbolTable.InternalTransformer
A transformer that replaces tree
from
with treeto
in a given treeA transformer that replaces tree
from
with treeto
in a given tree- Definition Classes
- Trees
- trait TreeStackTraverser extends internal.SymbolTable.InternalTraverser
- Definition Classes
- Trees
- class TreeSubstituter extends internal.SymbolTable.InternalTransformer
- Definition Classes
- Trees
- class TreeSymSubstTraverser extends internal.SymbolTable.TypeMapTreeSubstituter
- Definition Classes
- Trees
- class TreeSymSubstituter extends internal.SymbolTable.InternalTransformer
Substitute symbols in
from
with symbols into
.Substitute symbols in
from
with symbols into
. Returns a new tree using the new symbols and whose Ident and Select nodes are name-consistent with the new symbols.Note: This is currently a destructive operation on the original Tree. Trees currently assigned a symbol in
from
will be assigned the new symbols without copying, and trees that define symbols with aninfo
that refer a symbol infrom
will have a new type assigned.- Definition Classes
- Trees
- class TreeTypeSubstituter extends internal.SymbolTable.TypeMapTreeSubstituter
- Definition Classes
- Trees
- case class Try extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.TryApi with Product with Serializable
- Definition Classes
- Trees
- class TwoWayCache[J, S] extends AnyRef
- Definition Classes
- TwoWayCaches
- trait TypTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTreeApi
- Definition Classes
- Trees
- abstract class Type extends internal.SymbolTable.TypeApiImpl with internal.SymbolTable.Annotatable[internal.SymbolTable.Type]
The base class for all types
The base class for all types
- Definition Classes
- Types
- abstract class TypeApiImpl extends internal.SymbolTable.TypeApi
- Definition Classes
- Types
- case class TypeApply extends internal.SymbolTable.GenericApply with internal.SymbolTable.TypeApplyApi with Product with Serializable
- Definition Classes
- Trees
- abstract case class TypeBounds extends internal.SymbolTable.SubType with internal.SymbolTable.TypeBoundsApi with Product with Serializable
A class for the bounds of abstract types and type parameters
A class for the bounds of abstract types and type parameters
- Definition Classes
- Types
- case class TypeBoundsTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTree with internal.SymbolTable.TypeBoundsTreeApi with Product with Serializable
- Definition Classes
- Trees
- abstract class TypeCollector[T] extends internal.SymbolTable.TypeFolder
- Definition Classes
- TypeMaps
- class TypeConKind extends internal.SymbolTable.Kind
- Definition Classes
- Kinds
- class TypeConstraint extends AnyRef
A class expressing upper and lower bounds constraints of type variables, as well as their instantiations.
A class expressing upper and lower bounds constraints of type variables, as well as their instantiations.
- Definition Classes
- TypeConstraints
- case class TypeDef extends internal.SymbolTable.MemberDef with internal.SymbolTable.TypeDefApi with Product with Serializable
- Definition Classes
- Trees
- class TypeError extends Throwable
A throwable signalling a type error
A throwable signalling a type error
- Definition Classes
- Types
- abstract class TypeFolder extends (internal.SymbolTable.Type) => Unit
- Definition Classes
- TypeMaps
- abstract class TypeMap extends (internal.SymbolTable.Type) => internal.SymbolTable.Type
A prototype for mapping a function over all possible types
A prototype for mapping a function over all possible types
- Definition Classes
- TypeMaps
- class TypeMapTreeSubstituter extends internal.SymbolTable.InternalTraverser
- Definition Classes
- Trees
- sealed abstract class TypeName extends Name with internal.Names.TypeNameApi
- Definition Classes
- Names
- abstract class TypeNames extends internal.SymbolTable.Keywords with internal.SymbolTable.TypeNamesApi
- Definition Classes
- StdNames
- case class TypeParamVarargsAttachment extends Product with Serializable
An attachment carrying information between uncurry and erasure
An attachment carrying information between uncurry and erasure
- Definition Classes
- StdAttachments
- abstract case class TypeRef extends internal.SymbolTable.UniqueType with internal.SymbolTable.TypeRefApi with Product with Serializable
A class for named types of the form
<prefix>.<sym.name>[args]
Cannot be created directly; one should always usetypeRef
for creation.A class for named types of the form
<prefix>.<sym.name>[args]
Cannot be created directly; one should always usetypeRef
for creation. (@M: Otherwise hashing breaks)- Definition Classes
- Types
- class TypeSkolem extends internal.SymbolTable.TypeSymbol
A class for type parameters viewed from inside their scopes
A class for type parameters viewed from inside their scopes
- Definition Classes
- Symbols
- abstract class TypeSymbol extends internal.SymbolTable.Symbol with internal.SymbolTable.TypeSymbolApi
A class of type symbols.
A class of type symbols. Alias and abstract types are direct instances of this class. Classes are instances of a subclass.
- Definition Classes
- Symbols
- abstract class TypeTraverser extends internal.SymbolTable.TypeMap
- Definition Classes
- TypeMaps
- case class TypeTree extends internal.SymbolTable.Tree with internal.SymbolTable.TypTree with internal.SymbolTable.TypeTreeApi with Product with Serializable
- Definition Classes
- Trees
- class TypeUnwrapper extends (internal.SymbolTable.Type) => internal.SymbolTable.Type
- Definition Classes
- Types
- abstract case class TypeVar extends internal.SymbolTable.Type with Product with Serializable
A class representing a type variable: not used after phase
typer
.A class representing a type variable: not used after phase
typer
.A higher-kinded TypeVar has params (Symbols) and typeArgs (Types). A TypeVar with nonEmpty typeArgs can only be instantiated by a higher-kinded type that can be applied to those args. A TypeVar is much like a TypeRef, except it has special logic for equality and subtyping.
Precondition for this class, enforced structurally: args.isEmpty && params.isEmpty.
- Definition Classes
- Types
- case class Typed extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.TypedApi with Product with Serializable
- Definition Classes
- Trees
- class TypedLocator extends internal.SymbolTable.Locator
- Definition Classes
- Positions
- case class UnApply extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.UnApplyApi with Product with Serializable
- Definition Classes
- Trees
- class UndoLog extends Clearable
- Definition Classes
- TypeConstraints
- final class UniqueConstantType extends internal.SymbolTable.FoldableConstantType
- Definition Classes
- Types
- final class UniqueErasedValueType extends internal.SymbolTable.ErasedValueType
- Definition Classes
- Types
- final class UniqueLiteralType extends internal.SymbolTable.LiteralType
- Definition Classes
- Types
- final class UniqueSingleType extends internal.SymbolTable.SingleType
- Definition Classes
- Types
- final class UniqueSuperType extends internal.SymbolTable.SuperType
- Definition Classes
- Types
- final class UniqueThisType extends internal.SymbolTable.ThisType
- Definition Classes
- Types
- abstract class UniqueType extends internal.SymbolTable.Type with Product
A type that can be passed to unique(..) and be stored in the uniques map.
A type that can be passed to unique(..) and be stored in the uniques map.
- Definition Classes
- Types
- final class UniqueTypeBounds extends internal.SymbolTable.TypeBounds
- Definition Classes
- Types
- trait UntouchableTypeVar extends internal.SymbolTable.TypeVar
- Definition Classes
- Types
- case class ValDef extends internal.SymbolTable.ValOrDefDef with internal.SymbolTable.ValDefApi with Product with Serializable
- Definition Classes
- Trees
- abstract class ValOrDefDef extends internal.SymbolTable.MemberDef with internal.SymbolTable.ValOrDefDefApi
- Definition Classes
- Trees
- class ValidateException extends Exception
- Definition Classes
- Positions
- trait ValueClassDefinitions extends AnyRef
- Definition Classes
- Definitions
- class VarianceValidator extends internal.SymbolTable.InternalTraverser
Used in Refchecks.
Used in Refchecks. TODO - eliminate duplication with varianceInType
- Definition Classes
- Variances
- abstract class VariancedTypeMap extends internal.SymbolTable.TypeMap
- Definition Classes
- TypeMaps
Deprecated Type Members
- 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
- 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("This method has been removed from the public API. Import compat._ or migrate away.") @deprecated
- Deprecated
(Since version 2.13.0) compatibility with Scala 2.10 EOL
- abstract type CompilationUnit <: CompilationUnitContextApi
The type of compilation units.
The type of compilation units.
- Definition Classes
- Universe
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) c.enclosingTree-style APIs are now deprecated; consult the scaladoc for more information
- See also
- trait CompilationUnitContextApi extends AnyRef
Compilation unit describes a unit of work of the compilation run.
Compilation unit describes a unit of work of the compilation run. It provides such information as file name, textual representation of the unit and the underlying AST.
- Definition Classes
- Universe
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) c.enclosingTree-style APIs are now deprecated; consult the scaladoc for more information
- See also
- trait MacroCompatApi extends CompatApi
- abstract type Run <: RunContextApi
The type of compilation runs.
The type of compilation runs.
- Definition Classes
- Universe
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) c.enclosingTree-style APIs are now deprecated; consult the scaladoc for more information
- See also
- trait RunContextApi extends AnyRef
Compilation run uniquely identifies current invocation of the compiler (e.g.
Compilation run uniquely identifies current invocation of the compiler (e.g. can be used to implement per-run caches for macros) and provides access to units of work of the invocation (currently processed unit of work and the list of all units).
- Definition Classes
- Universe
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) c.enclosingTree-style APIs are now deprecated; consult the scaladoc for more information
- See also
- type Compat = MacroCompatApi
- type ModifiersCreator = ModifiersExtractor
- Definition Classes
- Trees
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use ModifiersExtractor instead
Value Members
- object Expr extends java.io.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
- 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 java.io.Serializable
- Definition Classes
- Printers
- object TypeTag extends java.io.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 java.io.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
- 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 toany2stringadd[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 toArrowAssoc[JavaUniverse] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @inline()
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- val AllOps: SymbolOps
- Definition Classes
- Symbols
- implicit val AlternativeTag: ClassTag[Alternative]
- Definition Classes
- Trees
- implicit val AnnotatedTag: ClassTag[Annotated]
- Definition Classes
- Trees
- implicit val AnnotatedTypeTag: ClassTag[AnnotatedType]
- Definition Classes
- Types
- implicit val AnnotationTag: ClassTag[AnnotationInfo]
- Definition Classes
- AnnotationInfos
- implicit def AnyNameOps(name: Name): NameOps[Name]
- Definition Classes
- Names
- implicit val AppliedTypeTreeTag: ClassTag[AppliedTypeTree]
- Definition Classes
- Trees
- def Apply(sym: Symbol, args: Tree*): Tree
A factory method for
Apply
nodes.A factory method for
Apply
nodes.- Definition Classes
- Trees → Trees
- def ApplyConstructor(tpt: Tree, args: List[Tree]): Apply
0-1 argument list new, based on a type tree.
0-1 argument list new, based on a type tree.
- Definition Classes
- Trees → Trees
- implicit val ApplyTag: ClassTag[Apply]
- Definition Classes
- Trees
- implicit val AssignTag: ClassTag[Assign]
- Definition Classes
- Trees
- def Bind(sym: Symbol, body: Tree): Bind
A factory method for
Bind
nodes.A factory method for
Bind
nodes.- Definition Classes
- Trees → Trees
- implicit val BindTag: ClassTag[Bind]
- Definition Classes
- Trees
- def Block(stats: Tree*): Block
Block factory that flattens directly nested blocks.
Block factory that flattens directly nested blocks.
- Definition Classes
- Trees → Trees
- implicit val BlockTag: ClassTag[Block]
- Definition Classes
- Trees
- final val BooleanTag: Int(2)
- Definition Classes
- Constants
- implicit val BoundedWildcardTypeTag: ClassTag[BoundedWildcardType]
- Definition Classes
- Types
- final val ByteTag: Int(3)
- Definition Classes
- Constants
- def CaseDef(pat: Tree, body: Tree): CaseDef
casedef shorthand
casedef shorthand
- Definition Classes
- Trees → Trees
- implicit val CaseDefTag: ClassTag[CaseDef]
- Definition Classes
- Trees
- final val CharTag: Int(5)
- Definition Classes
- Constants
- implicit val ClassDefTag: ClassTag[ClassDef]
- Definition Classes
- Trees
- implicit val ClassInfoTypeTag: ClassTag[ClassInfoType]
- Definition Classes
- Types
- implicit val ClassSymbolTag: ClassTag[ClassSymbol]
- Definition Classes
- Symbols
- final val ClazzTag: Int(12)
- Definition Classes
- Constants
- implicit val CompoundTypeTag: ClassTag[CompoundType]
- Definition Classes
- Types
- implicit val CompoundTypeTreeTag: ClassTag[CompoundTypeTree]
- Definition Classes
- Trees
- implicit val ConstantTag: ClassTag[Constant]
- Definition Classes
- Constants
- implicit val ConstantTypeTag: ClassTag[ConstantType]
- Definition Classes
- Types
- val CyclicInheritance: java.lang.Throwable
- Definition Classes
- BaseTypeSeqs
- implicit val DefDefTag: ClassTag[DefDef]
- Definition Classes
- Trees
- implicit val DefTreeTag: ClassTag[DefTree]
- Definition Classes
- Trees
- final val DoubleTag: Int(9)
- Definition Classes
- Constants
- lazy val EmptyTreeTypeSubstituter: TreeTypeSubstituter
- Definition Classes
- Trees
- final val EnumTag: Int(13)
- Definition Classes
- Constants
- implicit val ExistentialTypeTag: ClassTag[ExistentialType]
- Definition Classes
- Types
- implicit val ExistentialTypeTreeTag: ClassTag[ExistentialTypeTree]
- Definition Classes
- Trees
- def FlagOps(mask: Long): SymbolOps
- Definition Classes
- Symbols
- implicit val FlagSetTag: ClassTag[FlagSet]
- Definition Classes
- FlagSets
- final val FloatTag: Int(8)
- Definition Classes
- Constants
- implicit val FreeTermSymbolTag: ClassTag[FreeTermSymbol]
- Definition Classes
- Symbols
- implicit val FreeTypeSymbolTag: ClassTag[FreeTypeSymbol]
- Definition Classes
- Symbols
- implicit val FunctionTag: ClassTag[Function]
- Definition Classes
- Trees
- implicit val GenericApplyTag: ClassTag[GenericApply]
- Definition Classes
- Trees
- val GlbFailure: java.lang.Throwable
- Definition Classes
- GlbLubs
- def Ident(sym: Symbol): Ident
A factory method for
Ident
nodes.A factory method for
Ident
nodes.- Definition Classes
- Trees → Trees
- def Ident(name: String): Ident
A factory method for
Ident
nodes.A factory method for
Ident
nodes.- Definition Classes
- Trees → Trees
- implicit val IdentTag: ClassTag[Ident]
- Definition Classes
- Trees
- implicit val IfTag: ClassTag[If]
- Definition Classes
- Trees
- implicit val ImplDefTag: ClassTag[ImplDef]
- Definition Classes
- Trees
- implicit val ImportSelectorTag: ClassTag[ImportSelector]
- Definition Classes
- Trees
- implicit val ImportTag: ClassTag[Import]
- Definition Classes
- Trees
- final val IntTag: Int(6)
- Definition Classes
- Constants
- implicit val JavaArgumentTag: ClassTag[ClassfileAnnotArg]
- Definition Classes
- AnnotationInfos
- implicit val LabelDefTag: ClassTag[LabelDef]
- Definition Classes
- Trees
- implicit val LiteralTag: ClassTag[Literal]
- Definition Classes
- Trees
- final val LongTag: Int(7)
- Definition Classes
- Constants
- implicit val MatchTag: ClassTag[Match]
- Definition Classes
- Trees
- implicit val MemberDefTag: ClassTag[MemberDef]
- Definition Classes
- Trees
- implicit val MemberScopeTag: ClassTag[MemberScope]
- Definition Classes
- Scopes
- implicit val MethodSymbolTag: ClassTag[MethodSymbol]
- Definition Classes
- Symbols
- implicit val MethodTypeTag: ClassTag[MethodType]
- Definition Classes
- Types
- implicit val MirrorTag: ClassTag[Mirror]
- Definition Classes
- JavaMirrors → ImplicitTags
- 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
- implicit val ModifiersTag: ClassTag[Modifiers]
- Definition Classes
- Trees
- implicit val ModuleDefTag: ClassTag[ModuleDef]
- Definition Classes
- Trees
- implicit val ModuleSymbolTag: ClassTag[ModuleSymbol]
- Definition Classes
- Symbols
- implicit val NameTag: ClassTag[Name]
- Definition Classes
- Names
- implicit val NameTreeTag: ClassTag[NameTree]
- Definition Classes
- Trees
- implicit val NamedArgTag: ClassTag[NamedArg]
- Definition Classes
- Trees
- 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 → Trees
- def New(tpe: Type, argss: List[List[Tree]]): Tree
- Definition Classes
- Trees
- 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 → Trees
- 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 → Trees
- def NewFromConstructor(constructor: Symbol, args: Tree*): Apply
- Definition Classes
- Trees
- implicit val NewTag: ClassTag[New]
- Definition Classes
- Trees
- val NoFlags: FlagSet
The empty set of flags
The empty set of flags
- Definition Classes
- FlagSets → FlagSets
- val NoKindErrors: KindErrors
- Definition Classes
- Kinds
- 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
- final val NoPeriod: Int(0)
- Definition Classes
- SymbolTable
- val NoPosition: internal.util.NoPosition.type
A special "missing" position.
A special "missing" position.
- Definition Classes
- Positions → Positions
- final val NoRunId: Int(0)
- Definition Classes
- SymbolTable
- lazy val NoSymbol: NoSymbol
A special "missing" symbol.
A special "missing" symbol. Commonly used in the API to denote a default or empty value.
- Definition Classes
- Symbols → Symbols
- final val NoTag: Int(0)
- Definition Classes
- Constants
- final val NullTag: Int(11)
- Definition Classes
- Constants
- implicit val NullaryMethodTypeTag: ClassTag[NullaryMethodType]
- Definition Classes
- Types
- implicit val PackageDefTag: ClassTag[PackageDef]
- Definition Classes
- Trees
- def PerRunReporting: PerRunReporting
- Attributes
- protected
- Definition Classes
- JavaUniverse → Reporting
- implicit val PolyTypeTag: ClassTag[PolyType]
- Definition Classes
- Types
- implicit val PositionTag: ClassTag[Position]
- Definition Classes
- Positions
- implicit val RefTreeTag: ClassTag[RefTree]
- Definition Classes
- Trees
- implicit val ReferenceToBoxedTag: ClassTag[ReferenceToBoxed]
- Definition Classes
- Trees
- implicit val RefinedTypeTag: ClassTag[RefinedType]
- Definition Classes
- Types
- implicit val ReturnTag: ClassTag[Return]
- Definition Classes
- Trees
- implicit val RuntimeClassTag: ClassTag[RuntimeClass]
- Definition Classes
- JavaUniverse → ImplicitTags
- implicit val ScopeTag: ClassTag[Scope]
- Definition Classes
- Scopes
- def Select(qualifier: Tree, sym: Symbol): Select
A factory method for
Select
nodes.A factory method for
Select
nodes.- Definition Classes
- Trees → Trees
- def Select(qualifier: Tree, name: String): Select
A factory method for
Select
nodes. - implicit val SelectFromTypeTreeTag: ClassTag[SelectFromTypeTree]
- Definition Classes
- Trees
- implicit val SelectTag: ClassTag[Select]
- Definition Classes
- Trees
- final val ShortTag: Int(4)
- Definition Classes
- Constants
- implicit val SingleTypeTag: ClassTag[SingleType]
- Definition Classes
- Types
- implicit val SingletonTypeTag: ClassTag[SingletonType]
- Definition Classes
- Types
- implicit val SingletonTypeTreeTag: ClassTag[SingletonTypeTree]
- Definition Classes
- Trees
- implicit val StarTag: ClassTag[Star]
- Definition Classes
- Trees
- implicit val StringContextStripMarginOps: (StringContext) => StringContextStripMarginOps
Adds the
sm
String interpolator to a scala.StringContext.Adds the
sm
String interpolator to a scala.StringContext.- Definition Classes
- SymbolTable
- final val StringTag: Int(10)
- Definition Classes
- Constants
- def Super(sym: Symbol, mix: TypeName): Tree
A factory method for
Super
nodes.A factory method for
Super
nodes.- Definition Classes
- Trees → Trees
- def SuperSelect(clazz: Symbol, sym: Symbol): Tree
Creates a tree that selects a specific member
sym
without having to qualify thesuper
.Creates a tree that selects a specific member
sym
without having to qualify thesuper
. For example, given traitsB <:< A
, a classC <:< B
needs to invokeA.$init$
. IfA
is not a direct parent, a treesuper[A].$init$
would not type check ("does not name a parent"). So we generatesuper.$init$
and pre-assign the correct symbol. A special-case intypedSelectInternal
assigns the correct typeA
to thesuper
qualifier.- Definition Classes
- Trees
- implicit val SuperTag: ClassTag[Super]
- Definition Classes
- Trees
- implicit val SuperTypeTag: ClassTag[SuperType]
- Definition Classes
- Types
- implicit val SymTreeTag: ClassTag[SymTree]
- Definition Classes
- Trees
- implicit val SymbolTag: ClassTag[Symbol]
- Definition Classes
- Symbols
- def Template(sym: Symbol, body: List[Tree]): Template
- sym
the template's symbol
- body
trees that constitute the body of the template
- returns
the template
- Definition Classes
- Trees
- implicit val TemplateTag: ClassTag[Template]
- Definition Classes
- Trees
- implicit def TermNameOps(name: TermName): NameOps[TermName]
- Definition Classes
- Names
- implicit val TermNameTag: ClassTag[TermName]
- Definition Classes
- Names
- implicit val TermSymbolTag: ClassTag[TermSymbol]
- Definition Classes
- Symbols
- implicit val TermTreeTag: ClassTag[TermTree]
- Definition Classes
- Trees
- def This(sym: Symbol): Tree
A factory method for
This
nodes.A factory method for
This
nodes.- Definition Classes
- Trees → Trees
- implicit val ThisTag: ClassTag[This]
- Definition Classes
- Trees
- implicit val ThisTypeTag: ClassTag[ThisType]
- Definition Classes
- Types
- def Throw(tpe: Type, args: Tree*): Throw
A factory method for
Throw
nodes.A factory method for
Throw
nodes.- Definition Classes
- Trees → Trees
- implicit val ThrowTag: ClassTag[Throw]
- Definition Classes
- Trees
- implicit val TreeCopierTag: ClassTag[TreeCopier]
- Definition Classes
- JavaUniverse → ImplicitTags
- implicit val TreeTag: ClassTag[Tree]
- Definition Classes
- Trees
- def Try(body: Tree, cases: (Tree, Tree)*): Try
A factory method for
Try
nodes.A factory method for
Try
nodes.- Definition Classes
- Trees → Trees
- implicit val TryTag: ClassTag[Try]
- Definition Classes
- Trees
- implicit val TypTreeTag: ClassTag[TypTree]
- Definition Classes
- Trees
- implicit val TypeApplyTag: ClassTag[TypeApply]
- Definition Classes
- Trees
- implicit val TypeBoundsTag: ClassTag[TypeBounds]
- Definition Classes
- Types
- def TypeBoundsTree(sym: Symbol): TypeBoundsTree
- Definition Classes
- Trees
- def TypeBoundsTree(bounds: TypeBounds): TypeBoundsTree
- Definition Classes
- Trees
- implicit val TypeBoundsTreeTag: ClassTag[TypeBoundsTree]
- Definition Classes
- Trees
- implicit val TypeDefTag: ClassTag[TypeDef]
- Definition Classes
- Trees
- implicit def TypeNameOps(name: TypeName): NameOps[TypeName]
- Definition Classes
- Names
- implicit val TypeNameTag: ClassTag[TypeName]
- Definition Classes
- Names
- implicit val TypeRefTag: ClassTag[TypeRef]
- Definition Classes
- Types
- implicit val TypeSymbolTag: ClassTag[TypeSymbol]
- Definition Classes
- Symbols
- implicit val TypeTagg: ClassTag[Type]
- Definition Classes
- Types
- def TypeTree(tp: Type): TypeTree
A factory method for
TypeTree
nodes.A factory method for
TypeTree
nodes.- Definition Classes
- Trees → Trees
- implicit val TypeTreeTag: ClassTag[TypeTree]
- Definition Classes
- Trees
- implicit val TypedTag: ClassTag[Typed]
- Definition Classes
- Trees
- implicit val UnApplyTag: ClassTag[UnApply]
- Definition Classes
- Trees
- final val UnitTag: Int(1)
- Definition Classes
- Constants
- implicit val ValDefTag: ClassTag[ValDef]
- Definition Classes
- Trees
- implicit val ValOrDefDefTag: ClassTag[ValOrDefDef]
- Definition Classes
- Trees
- def abort(msg: String): Nothing
- Definition Classes
- Reporting
- def adaptAnnotations(tree: Tree, mode: Mode, pt: Type): Tree
- Definition Classes
- AnnotationCheckers
- def adaptBoundsToAnnotations(bounds: List[TypeBounds], tparams: List[Symbol], targs: List[Type]): List[TypeBounds]
- Definition Classes
- AnnotationCheckers
- See also
AnnotationChecker.adaptBoundsToAnnotations
- def adaptTypeOfReturn(tree: Tree, pt: Type, default: => Type): Type
- Definition Classes
- AnnotationCheckers
- def addAnnotationChecker(checker: AnnotationChecker): Unit
Register an annotation checker.
Register an annotation checker. Typically these are added by compiler plugins.
- Definition Classes
- AnnotationCheckers
- def addAnnotations(tree: Tree, tpe: Type): Type
- Definition Classes
- AnnotationCheckers
- implicit def addFlagOps(left: FlagSet): FlagOps
The API of
FlagSet
instances.The API of
FlagSet
instances.- Definition Classes
- FlagSets → FlagSets
- def addMember(thistp: Type, tp: Type, sym: Symbol, depth: Depth): Unit
Make symbol
sym
a member of scopetp.decls
wherethistp
is the narrowed owner type of the scope.Make symbol
sym
a member of scopetp.decls
wherethistp
is the narrowed owner type of the scope.- Definition Classes
- Types
- def addMember(thistp: Type, tp: Type, sym: Symbol): Unit
- Definition Classes
- Types
- def addSerializable(ps: Type*): List[Type]
- Definition Classes
- Types
- final def allNames(): Iterator[TermName]
- Definition Classes
- Names
- def annotatedType(annots: List[AnnotationInfo], underlying: Type): Type
Creator for AnnotatedTypes.
Creator for AnnotatedTypes. It returns the underlying type if annotations.isEmpty rather than walking into the assertion.
- Definition Classes
- Types
- def annotationToTree(ann: Annotation): Tree
- Attributes
- protected[scala]
- Definition Classes
- AnnotationInfos → Annotations
- def annotationsConform(tp1: Type, tp2: Type): Boolean
- Definition Classes
- AnnotationCheckers
- See also
AnnotationChecker.annotationsConform
- def annotationsGlb(tpe: Type, ts: List[Type]): Type
- Definition Classes
- AnnotationCheckers
- See also
AnnotationChecker.annotationsGlb
- def annotationsLub(tpe: Type, ts: List[Type]): Type
- Definition Classes
- AnnotationCheckers
- See also
AnnotationChecker.annotationsLub
- def appliedType(tyconSym: Symbol, args: Type*): Type
Very convenient.
Very convenient.
- Definition Classes
- Types → Types
- def appliedType(tyconSym: Symbol, args: List[Type]): Type
- Definition Classes
- Types → Types
- See also
- def appliedType(tycon: Type, args: Type*): Type
- Definition Classes
- Types → Types
- See also
- def appliedType(tycon: Type, args: List[Type]): Type
A creator for type applications
A creator for type applications
- Definition Classes
- Types → Types
- def arrayToRepeated(tp: Type): Type
Convert array parameters denoting a repeated parameter of a Java method to
JavaRepeatedParamClass
types.Convert array parameters denoting a repeated parameter of a Java method to
JavaRepeatedParamClass
types.- Definition Classes
- SymbolTable
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- final def assert(assertion: Boolean, message: => Any): Unit
- Definition Classes
- SymbolTable
- Annotations
- @inline()
- def assertCorrectThread(): Unit
Check that the executing thread is the compiler thread.
Check that the executing thread is the compiler thread. No-op here, overridden in interactive.Global.
- Definition Classes
- SymbolTable
- Annotations
- @elidable(elidable.WARNING)
- final def atPhaseStack: List[Phase]
- Definition Classes
- SymbolTable
- def atPhaseStackMessage: String
- Definition Classes
- SymbolTable
- def atPos[T <: Tree](pos: Position)(tree: T): T
Position a tree.
Position a tree. This means: Set position of a node and position all its unpositioned children.
- Definition Classes
- Positions → Positions
- def backquotedPath(t: Tree): String
Turns a path into a String, introducing backquotes as necessary.
Turns a path into a String, introducing backquotes as necessary.
- Definition Classes
- Printers
- def baseTypeSingletonSeq(tp: Type): BaseTypeSeq
Create a base type sequence consisting of a single type
Create a base type sequence consisting of a single type
- Definition Classes
- BaseTypeSeqs
- def basetypeRecursions: Int
- Definition Classes
- SynchronizedTypes → Types
- def basetypeRecursions_=(value: Int): Unit
- Definition Classes
- SynchronizedTypes → Types
- final def bitSetByPredicate[A](xs: List[A])(pred: (A) => Boolean): BitSet
- Definition Classes
- Collections
- val build: ReificationSupportImpl
- Definition Classes
- ReificationSupport
- def canAdaptAnnotations(tree: Tree, mode: Mode, pt: Type): Boolean
- Definition Classes
- AnnotationCheckers
- def captureVariable(vble: Symbol): Unit
Mark a variable as captured; i.e.
Mark a variable as captured; i.e. force boxing in a *Ref type.
- Definition Classes
- CapturedVariables
- def capturedVariableType(vble: Symbol, tpe: Type = NoType, erasedTypes: Boolean = false): Type
Convert type of a captured variable to *Ref type.
Convert type of a captured variable to *Ref type.
- Definition Classes
- CapturedVariables
- def capturedVariableType(vble: Symbol): Type
Convert type of a captured variable to *Ref type.
Convert type of a captured variable to *Ref type.
- Definition Classes
- CapturedVariables
- def changeNonLocalOwners(tree: Tree, newowner: Symbol): Unit
- Definition Classes
- Trees
- def checkKindBounds0(tparams: List[Symbol], targs: List[Type], pre: Type, owner: Symbol, explainErrors: Boolean): List[(Type, Symbol, KindErrors)]
Check well-kindedness of type application (assumes arities are already checked) -- @M
Check well-kindedness of type application (assumes arities are already checked) -- @M
This check is also performed when abstract type members become concrete (aka a "type alias") -- then tparams.length==1 (checked one type member at a time -- in that case, prefix is the name of the type alias)
Type application is just like value application: it's "contravariant" in the sense that the type parameters of the supplied type arguments must conform to the type parameters of the required type parameters:
- their bounds must be less strict
- variances must match (here, variances are absolute, the variance of a type parameter does not influence the variance of its higher-order parameters)
- @M TODO: are these conditions correct,sufficient&necessary?
e.g. class Iterable[t, m[+x <: t]] --> the application Iterable[Int, List] is okay, since List's type parameter is also covariant and its bounds are weaker than <: Int
- Definition Classes
- Kinds
- val chrs: Array[Char]
Memory to store all names sequentially.
Memory to store all names sequentially.
- Definition Classes
- Names
- def clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def cloneSymbols(syms: List[Symbol]): List[Symbol]
Convenience functions which derive symbols by cloning.
Convenience functions which derive symbols by cloning.
- Definition Classes
- Symbols
- def cloneSymbolsAndModify(syms: List[Symbol], infoFn: (Type) => Type): List[Symbol]
Clone symbols and apply the given function to each new symbol's info.
Clone symbols and apply the given function to each new symbol's info.
- syms
the prototypical symbols
- infoFn
the function to apply to the infos
- returns
the newly created, info-adjusted symbols
- Definition Classes
- Symbols
- def cloneSymbolsAtOwner(syms: List[Symbol], owner: Symbol): List[Symbol]
- Definition Classes
- Symbols
- def cloneSymbolsAtOwnerAndModify(syms: List[Symbol], owner: Symbol, infoFn: (Type) => Type): List[Symbol]
- Definition Classes
- Symbols
- final def closestEnclMethod(from: Symbol): Symbol
Return closest enclosing method, unless shadowed by an enclosing class.
Return closest enclosing method, unless shadowed by an enclosing class.
- Definition Classes
- Symbols
- Annotations
- @tailrec()
- final def collectFirst[A, B](as: List[A])(pf: PartialFunction[A, B]): Option[B]
- Definition Classes
- Collections
- final def collectMap2[A, B, C](xs1: List[A], xs2: List[B])(p: (A, B) => Boolean): Map[A, B]
- Definition Classes
- Collections
- def commonOwner(tps: List[Type]): Symbol
The most deeply nested owner that contains all the symbols of thistype or prefixless typerefs/singletype occurrences in given list of types.
The most deeply nested owner that contains all the symbols of thistype or prefixless typerefs/singletype occurrences in given list of types.
- Attributes
- protected[scala.reflect.internal]
- Definition Classes
- CommonOwners
- def commonOwner(t: Type): Symbol
The most deeply nested owner that contains all the symbols of thistype or prefixless typerefs/singletype occurrences in given type.
The most deeply nested owner that contains all the symbols of thistype or prefixless typerefs/singletype occurrences in given type.
- Attributes
- protected[scala.reflect.internal]
- Definition Classes
- CommonOwners
- def commonOwnerMap: CommonOwnerMap
- Attributes
- protected
- Definition Classes
- SynchronizedTypes → CommonOwners
- final def compareLengths(xs1: List[_], xs2: List[_]): Int
- Definition Classes
- Collections
- Annotations
- @tailrec()
- def compoundBaseTypeSeq(tp: Type): BaseTypeSeq
Create the base type sequence of a compound type with given tp.parents
Create the base type sequence of a compound type with given tp.parents
- Definition Classes
- BaseTypeSeqs
- def computeBaseClasses(tpe: Type): List[Symbol]
- Attributes
- protected
- Definition Classes
- Types
- def connectModuleToClass(m: ModuleSymbol, moduleClass: ClassSymbol): ModuleSymbol
- Definition Classes
- SynchronizedSymbols → Symbols
- def containsExistential(tpe: Type): Boolean
- Definition Classes
- Types
- def copyClassDef(tree: Tree)(mods: Modifiers = null, name: Name = null, tparams: List[TypeDef] = null, impl: Template = null): ClassDef
- Definition Classes
- Trees
- def copyDefDef(tree: Tree)(mods: Modifiers = null, name: Name = null, tparams: List[TypeDef] = null, vparamss: List[List[ValDef]] = null, tpt: Tree = null, rhs: Tree = null): DefDef
- Definition Classes
- Trees
- def copyMethodType(tp: Type, params: List[Symbol], restpe: Type): Type
Create a new MethodType
Create a new MethodType
- Definition Classes
- Types
- def copyModuleDef(tree: Tree)(mods: Modifiers = null, name: Name = null, impl: Template = null): ModuleDef
- Definition Classes
- Trees
- def copyRefinedType(original: RefinedType, parents: List[Type], decls: Scope): Type
- Definition Classes
- Types
- def copyTypeDef(tree: Tree)(mods: Modifiers = null, name: Name = null, tparams: List[TypeDef] = null, rhs: Tree = null): TypeDef
- Definition Classes
- Trees
- def copyTypeRef(tp: Type, pre: Type, sym: Symbol, args: List[Type]): Type
- Definition Classes
- Types
- def copyValDef(tree: Tree)(mods: Modifiers = null, name: Name = null, tpt: Tree = null, rhs: Tree = null): ValDef
- Definition Classes
- Trees
- final def corresponds3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) => Boolean): Boolean
True if all three arguments have the same number of elements and the function is true for all the triples.
True if all three arguments have the same number of elements and the function is true for all the triples.
- Definition Classes
- Collections
- Annotations
- @tailrec()
- def createFromClonedSymbols[T](syms: List[Symbol], tpe: Type)(creator: (List[Symbol], Type) => T): T
Functions which perform the standard clone/substituting on the given symbols and type, then call the creator function with the new symbols and type as arguments.
Functions which perform the standard clone/substituting on the given symbols and type, then call the creator function with the new symbols and type as arguments.
- Definition Classes
- Symbols
- def createFromClonedSymbolsAtOwner[T](syms: List[Symbol], owner: Symbol, tpe: Type)(creator: (List[Symbol], Type) => T): T
- Definition Classes
- Symbols
- def currentFreshNameCreator: FreshNameCreator
- Definition Classes
- JavaUniverse → FreshNames
- final def currentPeriod: Period
The current period.
The current period.
- Definition Classes
- SymbolTable
- def currentRun: RunReporting
- Definition Classes
- JavaUniverse → Reporting
- val currentRunId: Int
The current compiler run identifier.
The current compiler run identifier.
- Definition Classes
- ReflectSetup → SymbolTable
- def currentRunProfilerAfterCompletion(root: Symbol, associatedFile: AbstractFile): Unit
- Attributes
- protected[scala]
- Definition Classes
- SymbolTable
- def currentRunProfilerBeforeCompletion(root: Symbol, associatedFile: AbstractFile): Unit
- Attributes
- protected[scala]
- Definition Classes
- SymbolTable
- def debugInfo(msg: => String): Unit
- Definition Classes
- SymbolTable
- def debugStack(t: Throwable): Unit
Prints a stack trace if -Ydebug or equivalent was given, otherwise does nothing.
Prints a stack trace if -Ydebug or equivalent was given, otherwise does nothing.
- Definition Classes
- SymbolTable
- def debugString(tp: Type): String
- Definition Classes
- TypeDebugging
- def debuglog(msg: => String): Unit
Override with final implementation for inlining.
Override with final implementation for inlining.
- Definition Classes
- SymbolTable
- def decodedSymName(tree: Tree, name: Name): String
- Definition Classes
- Printers
- def defineBaseClassesOfCompoundType(tpe: CompoundType): Unit
- Attributes
- protected
- Definition Classes
- SynchronizedTypes → Types
- def defineBaseTypeSeqOfCompoundType(tpe: CompoundType): Unit
- Attributes
- protected
- Definition Classes
- SynchronizedTypes → Types
- def defineBaseTypeSeqOfTypeRef(tpe: TypeRef): Unit
- Attributes
- protected
- Definition Classes
- SynchronizedTypes → Types
- def defineOriginalOwner(sym: Symbol, owner: Symbol): Unit
- Definition Classes
- Symbols
- def defineParentsOfTypeRef(tpe: TypeRef): Unit
- Attributes
- protected
- Definition Classes
- SynchronizedTypes → Types
- def defineUnderlyingOfSingleType(tpe: SingleType): Unit
- Attributes
- protected
- Definition Classes
- SynchronizedTypes → Types
- def deriveCaseDef(cdef: Tree)(applyToBody: (Tree) => Tree): CaseDef
- Definition Classes
- Trees
- def deriveClassDef(cdef: Tree)(applyToImpl: (Template) => Template): ClassDef
- Definition Classes
- Trees
- def deriveDefDef(ddef: Tree)(applyToRhs: (Tree) => Tree): DefDef
- Definition Classes
- Trees
- def deriveFreshSkolems(tparams: List[Symbol]): List[Symbol]
Map a list of type parameter symbols to skolemized symbols, which can be deskolemized to the original type parameter.
Map a list of type parameter symbols to skolemized symbols, which can be deskolemized to the original type parameter. (A skolem is a representation of a bound variable when viewed inside its scope.) !!!Adriaan: this does not work for hk types.
Skolems will be created at level 0, rather than the current value of
skolemizationLevel
. (See scala/bug#7782)- Definition Classes
- ExistentialsAndSkolems
- def deriveFunction(func: Tree)(applyToRhs: (Tree) => Tree): Function
- Definition Classes
- Trees
- def deriveLabelDef(ldef: Tree)(applyToRhs: (Tree) => Tree): LabelDef
- Definition Classes
- Trees
- def deriveModuleDef(mdef: Tree)(applyToImpl: (Template) => Template): ModuleDef
- Definition Classes
- Trees
- def deriveSymbols(syms: List[Symbol], symFn: (Symbol) => Symbol): List[Symbol]
Derives a new list of symbols from the given list by mapping the given list across the given function.
Derives a new list of symbols from the given list by mapping the given list across the given function. Then fixes the info of all the new symbols by substituting the new symbols for the original symbols.
- syms
the prototypical symbols
- symFn
the function to create new symbols
- returns
the new list of info-adjusted symbols
- Definition Classes
- Symbols
- def deriveSymbols2[A](syms: List[Symbol], as: List[A], symFn: (Symbol, A) => Symbol): List[Symbol]
Derives a new list of symbols from the given list by mapping the given list of
syms
andas
across the given function.Derives a new list of symbols from the given list by mapping the given list of
syms
andas
across the given function. Then fixes the info of all the new symbols by substituting the new symbols for the original symbols.- syms
the prototypical symbols
- as
arguments to be passed to symFn together with symbols from syms (must be same length)
- symFn
the function to create new symbols
- returns
the new list of info-adjusted symbols
- Definition Classes
- Symbols
- def deriveTemplate(templ: Tree)(applyToBody: (List[Tree]) => List[Tree]): Template
- Definition Classes
- Trees
- def deriveType(syms: List[Symbol], symFn: (Symbol) => Symbol)(tpe: Type): Type
Derives a new Type by first deriving new symbols as in deriveSymbols, then performing the same oldSyms => newSyms substitution on
tpe
as is performed on the symbol infos in deriveSymbols.Derives a new Type by first deriving new symbols as in deriveSymbols, then performing the same oldSyms => newSyms substitution on
tpe
as is performed on the symbol infos in deriveSymbols.- syms
the prototypical symbols
- symFn
the function to create new symbols
- tpe
the prototypical type
- returns
the new symbol-substituted type
- Definition Classes
- Symbols
- def deriveType2[A](syms: List[Symbol], as: List[A], symFn: (Symbol, A) => Symbol)(tpe: Type): Type
Derives a new Type by first deriving new symbols as in deriveSymbols2, then performing the same oldSyms => newSyms substitution on
tpe
as is performed on the symbol infos in deriveSymbols.Derives a new Type by first deriving new symbols as in deriveSymbols2, then performing the same oldSyms => newSyms substitution on
tpe
as is performed on the symbol infos in deriveSymbols.- syms
the prototypical symbols
- as
arguments to be passed to symFn together with symbols from syms (must be same length)
- symFn
the function to create new symbols based on
as
- tpe
the prototypical type
- returns
the new symbol-substituted type
- Definition Classes
- Symbols
- def deriveTypeWithWildcards(syms: List[Symbol])(tpe: Type): Type
Derives a new Type by instantiating the given list of symbols as WildcardTypes.
Derives a new Type by instantiating the given list of symbols as WildcardTypes.
- syms
the symbols to replace
- returns
the new type with WildcardType replacing those syms
- Definition Classes
- Symbols
- def deriveValDef(vdef: Tree)(applyToRhs: (Tree) => Tree): ValDef
- Definition Classes
- Trees
- def devWarning(msg: => String): Unit
- Definition Classes
- SymbolTable
- final def devWarningDumpStack(msg: => String, maxFrames: Int): Unit
- Definition Classes
- SymbolTable
- Annotations
- @inline()
- final def devWarningIf(cond: => Boolean)(msg: => String): Unit
dev-warns if dev-warning is enabled and
cond
is true; no-op otherwisedev-warns if dev-warning is enabled and
cond
is true; no-op otherwise- Definition Classes
- SymbolTable
- Annotations
- @inline()
- final def distinctBy[A, B](xs: List[A])(f: (A) => B): List[A]
- Definition Classes
- Collections
- def duplicateAndKeepPositions(tree: Tree): Tree
- Definition Classes
- Trees
- def elapsedMessage(msg: String, startNs: Long): String
- Attributes
- protected
- Definition Classes
- SymbolTable
- def elementExtract(container: Symbol, tp: Type): Type
- Definition Classes
- Types
- def elementExtractOption(container: Symbol, tp: Type): Option[Type]
- Definition Classes
- Types
- def elementTest(container: Symbol, tp: Type)(f: (Type) => Boolean): Boolean
- Definition Classes
- Types
- def elementTransform(container: Symbol, tp: Type)(f: (Type) => Type): Type
- Definition Classes
- Types
- def elimAnonymousClass(t: Type): Type
- Definition Classes
- Types
- def encode(str: String): TermName
- Definition Classes
- StdNames
- def ensureNonOverlapping(tree: Tree, others: List[Tree], focus: Boolean): Unit
- Definition Classes
- Positions
- def ensureNonOverlapping(tree: Tree, others: List[Tree]): Unit
Ensure that given tree has no positions that overlap with any of the positions of
others
.Ensure that given tree has no positions that overlap with any of the positions of
others
. This is done by shortening the range, assigning TransparentPositions to some of the nodes intree
or focusing on the position.- Definition Classes
- Positions
- def ensuring(cond: (JavaUniverse) => Boolean, msg: => Any): JavaUniverse
- Implicit
- This member is added by an implicit conversion from JavaUniverse toEnsuring[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 toEnsuring[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 toEnsuring[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 toEnsuring[JavaUniverse] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- final def enteringPhase[T](ph: Phase)(op: => T): T
Perform given operation at given phase.
Perform given operation at given phase.
- Definition Classes
- SymbolTable
- Annotations
- @inline()
- final def enteringPhaseNotLaterThan[T](target: Phase)(op: => T): T
- Definition Classes
- SymbolTable
- Annotations
- @inline()
- final def enteringPhaseWithName[T](phaseName: String)(body: => T): T
- Definition Classes
- SymbolTable
- final def enteringPrevPhase[T](op: => T): T
- Definition Classes
- SymbolTable
- Annotations
- @inline()
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def erasure: Erasure { val global: JavaUniverse.this.type }
- Definition Classes
- Transforms
- def erasurePhase: SomePhase
- Definition Classes
- JavaUniverse → SymbolTable
- def existentialAbstraction(tparams: List[Symbol], tpe0: Type, flipVariance: Boolean = false): Type
A creator for existential types.
A creator for existential types. This generates:
tpe1 where { tparams }
where
tpe1
is the result of extrapolatingtpe
with respect totparams
. Extrapolating means that type variables intparams
occurring in covariant positions are replaced by upper bounds, (minus any SingletonClass markers), type variables intparams
occurring in contravariant positions are replaced by upper bounds, provided the resulting type is legal with regard to stability, and does not contain any type variable intparams
.The abstraction drops all type parameters that are not directly or indirectly referenced by type
tpe1
. If there are no remaining type parameters, simply returns result typetpe
.- Definition Classes
- Types
- final def existentialTransform[T](rawSyms: List[Symbol], tp: Type, rawOwner: Symbol = NoSymbol)(creator: (List[Symbol], Type) => T): T
Given a set
rawSyms
of term- and type-symbols, and a typetp
, produce a set of fresh type parameters and a type so that it can be abstracted to an existential type.Given a set
rawSyms
of term- and type-symbols, and a typetp
, produce a set of fresh type parameters and a type so that it can be abstracted to an existential type. Every type symbolT
inrawSyms
is mapped to a clone. Every term symbolx
of typeT
inrawSyms
is given an associated type symbol of the following form:type x.type <: T with Singleton
The name of the type parameter is
x.type
, to produce nice diagnostics. The Singleton parent ensures that the type parameter is still seen as a stable type. Type symbols in rawSyms are fully replaced by the new symbols. Term symbols are also replaced, except for term symbols of an Ident tree, where only the type of the Ident is changed.- Definition Classes
- ExistentialsAndSkolems
- def existentialsInType(tpe: Type): List[Symbol]
- Definition Classes
- Types
- def existingSymbols(syms: List[Symbol]): List[Symbol]
- Definition Classes
- Symbols
- final def exists2[A, B](xs1: List[A], xs2: List[B])(f: (A, B) => Boolean): Boolean
- Definition Classes
- Collections
- final def exists3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) => Boolean): Boolean
- Definition Classes
- Collections
- final def exitingPhase[T](ph: Phase)(op: => T): T
- Definition Classes
- SymbolTable
- Annotations
- @inline()
- def explain[T](op: String, p: (Type, T) => Boolean, tp1: Type, arg2: T): Boolean
Perform operation
p
on argumentstp1
,arg2
and print trace of computation.Perform operation
p
on argumentstp1
,arg2
and print trace of computation.- Attributes
- protected
- Definition Classes
- Types
- def explainTypes(op: (Type, Type) => Any, found: Type, required: Type): Unit
If option
explaintypes
is set, print a subtype trace forop(found, required)
.If option
explaintypes
is set, print a subtype trace forop(found, required)
.- Definition Classes
- Types
- def explainTypes(found: Type, required: Type): Unit
If option
explaintypes
is set, print a subtype trace forfound <:< required
.If option
explaintypes
is set, print a subtype trace forfound <:< required
.- Definition Classes
- Types
- def finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- final def findOrElse[A](xs: IterableOnce[A])(p: (A) => Boolean)(orElse: => A): A
- Definition Classes
- Collections
- final def findPhaseWithName(phaseName: String): Phase
- Definition Classes
- SymbolTable
- final def findSymbol(xs: IterableOnce[Symbol])(p: (Symbol) => Boolean): Symbol
- Definition Classes
- SymbolTable
- Annotations
- @inline()
- final def flatCollect[A, B](elems: List[A])(pf: PartialFunction[A, Iterable[B]]): List[B]
- Definition Classes
- Collections
- final def flatMap2[A, B, C](xs1: List[A], xs2: List[B])(f: (A, B) => List[C]): List[C]
- Definition Classes
- Collections
- final def flattensToEmpty(xss: Seq[Seq[_]]): Boolean
- Definition Classes
- Collections
- Annotations
- @tailrec()
- final def focusInPlace(t: Tree): t.type
- Definition Classes
- Trees
- final def foldLeft2[A1, A2, B](xs1: List[A1], xs2: List[A2])(z0: B)(f: (B, A1, A2) => B): B
- Definition Classes
- Collections
- final def forall3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) => Boolean): Boolean
- Definition Classes
- Collections
- def force(): Unit
- Definition Classes
- JavaUniverseForce
- final def foreach2[A, B](xs1: List[A], xs2: List[B])(f: (A, B) => Unit): Unit
- Definition Classes
- Collections
- final def foreach3[A, B, C](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) => Unit): Unit
- Definition Classes
- Collections
- def foreachParamss(sym: Symbol)(f: (Symbol) => Unit): Unit
- Definition Classes
- Symbols
- final def foreachWithIndex[A](xs: List[A])(f: (A, Int) => Unit): Unit
- Definition Classes
- Collections
- def formatted(fmtstr: String): String
- Implicit
- This member is added by an implicit conversion from JavaUniverse toStringFormat[JavaUniverse] performed by method StringFormat in scala.Predef.
- Definition Classes
- StringFormat
- Annotations
- @inline()
- def freshExistentialName(suffix: String, id: Int): TypeName
- Attributes
- protected
- Definition Classes
- Symbols
- def freshTermName(prefix: String = nme.FRESH_TERM_NAME_PREFIX)(implicit creator: FreshNameCreator): TermName
- Definition Classes
- FreshNames
- def freshTypeName(prefix: String)(implicit creator: FreshNameCreator): TypeName
- Definition Classes
- FreshNames
- val gen: internal.TreeGen { val global: JavaUniverse.this.type }
- Definition Classes
- SymbolTable
- def genPolyType(params: List[Symbol], tpe: Type): Type
- Definition Classes
- Types
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def getCurrentSymbolIdCount: Int
- Definition Classes
- Symbols
- final def gilSynchronized[T](body: => T): T
- Definition Classes
- Gil
- Annotations
- @inline()
- def glb(ts: List[Type], depth: Depth): Type
- Attributes
- protected[scala.reflect.internal]
- Definition Classes
- GlbLubs
- 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
- GlbLubs
- def glbNorm(ts: List[Type], depth: Depth): Type
The greatest lower bound of a list of types (as determined by
<:<
), which have been normalized with regard toelimSuper
.The greatest lower bound of a list of types (as determined by
<:<
), which have been normalized with regard toelimSuper
.- Attributes
- protected
- Definition Classes
- GlbLubs
- def glbResults: HashMap[(Depth, List[Type]), Type]
- Definition Classes
- SynchronizedTypes → GlbLubs
- def globalError(pos: Position, msg: String): Unit
- Definition Classes
- Reporting
- Annotations
- @deprecatedOverriding("This forwards to the corresponding method in reporter -- override reporter instead", "2.11.2")
- def globalError(msg: String): Unit
- Definition Classes
- Reporting
- Annotations
- @deprecatedOverriding("This forwards to the corresponding method in reporter -- override reporter instead", "2.11.2")
- val globalFreshNameCreator: FreshNameCreator
- Definition Classes
- FreshNames
- final def hasLength(xs: List[_], len: Int): Boolean
Again avoiding calling length, but the lengthCompare interface is clunky.
Again avoiding calling length, but the lengthCompare interface is clunky.
- Definition Classes
- Collections
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def howManyUniqueTypes: Int
- Definition Classes
- Types
- val ids: Int
- Attributes
- protected
- Definition Classes
- Symbols
- def importableMembers(pre: Type): Scope
Members which can be imported into other scopes.
Members which can be imported into other scopes.
- Definition Classes
- Types
- def indent: String
- Definition Classes
- SynchronizedTypes → Types
- def indent_=(value: String): Unit
- Definition Classes
- SynchronizedTypes → Types
- def info(msg: => String): Unit
- Definition Classes
- SymbolTable
- var infoTransformers: InfoTransformer
The set of all installed infotransformers.
The set of all installed infotransformers.
- Definition Classes
- SymbolTable
- def inform(pos: Position, msg: String): Unit
- Definition Classes
- Reporting
- Annotations
- @deprecatedOverriding("This forwards to the corresponding method in reporter -- override reporter instead", "2.11.2")
- def inform(msg: String): Unit
- Definition Classes
- Reporting
- Annotations
- @deprecatedOverriding("This forwards to the corresponding method in reporter -- override reporter instead", "2.11.2")
- def informProgress(msg: String): Unit
- Definition Classes
- SymbolTable
- def informTime(msg: String, startNs: Long): Unit
- Definition Classes
- SymbolTable
- final def informingProgress[T](msg: => String)(fn: => T): T
- Definition Classes
- SymbolTable
- Annotations
- @inline()
- def inheritsJavaVarArgsMethod(clazz: Symbol): Boolean
- Definition Classes
- Types
- def init(): Unit
- def initAndEnterClassAndModule(owner: Symbol, name: TypeName, completer: (ClassSymbol, ModuleSymbol) => LazyType): (ClassSymbol, ModuleSymbol)
Create a class and a companion object, enter in enclosing scope, and initialize with a lazy type completer.
Create a class and a companion object, enter in enclosing scope, and initialize with a lazy type completer.
- owner
The owner of the newly created class and object
- name
The simple name of the newly created class
- completer
The completer to be used to set the info of the class and the module
- Attributes
- protected
- Definition Classes
- SymbolLoaders
- def initClassAndModule(clazz: Symbol, module: Symbol, completer: LazyType): Unit
- Attributes
- protected
- Definition Classes
- SymbolLoaders
- def instantiatedBounds(pre: Type, owner: Symbol, tparams: List[Symbol], targs: List[Type]): List[TypeBounds]
- Definition Classes
- Types
- lazy val internal: Internal
- Definition Classes
- JavaUniverse → Internals → Internals
- See also
- def intersectionType(tps: List[Type]): Type
A creator for intersection type where intersections of a single type are replaced by the type itself.
A creator for intersection type where intersections of a single type are replaced by the type itself.
- Definition Classes
- Types
- def intersectionType(tps: List[Type], owner: Symbol): Type
A creator for intersection type where intersections of a single type are replaced by the type itself, and repeated parent classes are merged.
A creator for intersection type where intersections of a single type are replaced by the type itself, and repeated parent classes are merged.
!!! Repeated parent classes are not merged - is this a bug in the comment or in the code?
- Definition Classes
- Types
- def intersectionTypeForLazyBaseType(tps: List[Type]): Type
- Definition Classes
- Types
- def intersectionWitness: WeakHashMap[List[Type], WeakReference[Type]]
- Definition Classes
- SynchronizedTypes → Types
- def invalidateCaches(t: Type, updatedSyms: List[Symbol]): Unit
- Definition Classes
- Types
- def invalidateTreeTpeCaches(tree: Tree, updatedSyms: List[Symbol]): Unit
- Definition Classes
- Types
- final def isAtPhaseAfter(p: Phase): Boolean
Are we later than given phase in compilation?
Are we later than given phase in compilation?
- Definition Classes
- SymbolTable
- def isBoundedGeneric(tp: Type): Boolean
- Definition Classes
- Types
- def isCompilerUniverse: Boolean
Declares that this is a runtime reflection universe.
Declares that this is a runtime reflection universe.
This means that we can make certain assumptions to optimize the universe. For example, we may auto-initialize symbols on flag and annotation requests (see
shouldTriggerCompleter
below for more details).On the other hand, this also means that usage scenarios of the universe will differ from the conventional ones. For example, we have to do additional cleanup in order to prevent memory leaks: http://groups.google.com/group/scala-internals/browse_thread/thread/eabcf3d406dab8b2.
- Definition Classes
- SymbolTable → SymbolTable
- def isConstantType(tp: Type): Boolean
- Definition Classes
- Types
- final def isDeveloper: Boolean
- Definition Classes
- SymbolTable
- def isDifferentType(tp1: Type, tp2: Type): Boolean
- Definition Classes
- TypeComparers
- def isDifferentTypeConstructor(tp1: Type, tp2: Type): Boolean
- Definition Classes
- TypeComparers
- def isDummyAppliedType(tp: Type): Boolean
- Definition Classes
- Types
- final def isEligibleForPrefixUnification(tp: Type): Boolean
Does this type have a prefix that begins with a type variable, or is it a refinement type? For type prefixes that fulfil this condition, type selections with the same name of equal (as determined by
=:=
) prefixes are considered equal in regard to=:=
.Does this type have a prefix that begins with a type variable, or is it a refinement type? For type prefixes that fulfil this condition, type selections with the same name of equal (as determined by
=:=
) prefixes are considered equal in regard to=:=
.- Definition Classes
- Types
- Annotations
- @tailrec()
- def isErrorOrWildcard(tp: Type): Boolean
- Definition Classes
- Types
- final def isExistentialType(tp: Type): Boolean
- Definition Classes
- Types
- Annotations
- @tailrec()
- def isHKSubType(tp1: Type, tp2: Type, depth: Depth): Boolean
- Definition Classes
- TypeComparers
- def isImplicitMethodType(tp: Type): Boolean
- Definition Classes
- Types
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def isIntersectionTypeForLazyBaseType(tp: RefinedType): Boolean
- Definition Classes
- Types
- def isJavaVarargsAncestor(clazz: Symbol): Boolean
- Definition Classes
- Types
- def isNonRefinementClassType(tpe: Type): Boolean
def isNonValueType(tp: Type) = !isValueElseNonValue(tp)
def isNonValueType(tp: Type) = !isValueElseNonValue(tp)
- Definition Classes
- Types
- def isNumericSubType(tp1: Type, tp2: Type): Boolean
- Definition Classes
- TypeComparers
- def isPastTyper: Boolean
- Definition Classes
- SymbolTable
- def isPopulated(tp1: Type, tp2: Type): Boolean
Is intersection of given types populated? That is, for all types tp1, tp2 in intersection for all common base classes bc of tp1 and tp2 let bt1, bt2 be the base types of tp1, tp2 relative to class bc Then: bt1 and bt2 have the same prefix, and any corresponding non-variant type arguments of bt1 and bt2 are the same
Is intersection of given types populated? That is, for all types tp1, tp2 in intersection for all common base classes bc of tp1 and tp2 let bt1, bt2 be the base types of tp1, tp2 relative to class bc Then: bt1 and bt2 have the same prefix, and any corresponding non-variant type arguments of bt1 and bt2 are the same
- Definition Classes
- Types
- def isPossiblePrefix(clazz: Symbol): Boolean
Might the given symbol be important when calculating the prefix of a type? When tp.asSeenFrom(pre, clazz) is called on
tp
, the result will betp
unchanged ifpre
is trivial andclazz
is a symbol such that isPossiblePrefix(clazz) == false.Might the given symbol be important when calculating the prefix of a type? When tp.asSeenFrom(pre, clazz) is called on
tp
, the result will betp
unchanged ifpre
is trivial andclazz
is a symbol such that isPossiblePrefix(clazz) == false.- Definition Classes
- TypeMaps
- def isRawIfWithoutArgs(sym: Symbol): Boolean
- Definition Classes
- Types
- def isRawParameter(sym: Symbol): Boolean
- Definition Classes
- ExistentialsAndSkolems
- def isRawType(tp: Type): Boolean
Is type tp a raw type?
Is type tp a raw type?
- Definition Classes
- Types
- def isSameType(tp1: Type, tp2: Type): Boolean
Do
tp1
andtp2
denote equivalent types?Do
tp1
andtp2
denote equivalent types?- Definition Classes
- TypeComparers
- def isSameType2(tp1: Type, tp2: Type): Boolean
- Definition Classes
- TypeComparers
- def isSameTypes(tps1: List[Type], tps2: List[Type]): Boolean
Are
tps1
andtps2
lists of pairwise equivalent types?Are
tps1
andtps2
lists of pairwise equivalent types?- Definition Classes
- Types
- def isSingleType(tp: Type): Boolean
This appears to be equivalent to tp.isInstanceof[SingletonType], except it excludes FoldableConstantTypes.
This appears to be equivalent to tp.isInstanceof[SingletonType], except it excludes FoldableConstantTypes.
- Definition Classes
- Types
- def isSubArgs(tps1: List[Type], tps2: List[Type], tparams: List[Symbol], depth: Depth): Boolean
- Definition Classes
- Types
- def isSubType(tp1: Type, tp2: Type, depth: Depth = Depth.AnyDepth): Boolean
- Definition Classes
- TypeComparers
- def isTreeSymbolPickled(tree: Tree): Boolean
This method should be equivalent to tree.hasSymbolField, but that method doesn't do us any good when we're unpickling because we need to know based on the Int tag - the tree doesn't exist yet.
This method should be equivalent to tree.hasSymbolField, but that method doesn't do us any good when we're unpickling because we need to know based on the Int tag - the tree doesn't exist yet. Thus, this method is documentation only.
- Definition Classes
- Translations
- def isTreeSymbolPickled(code: Int): Boolean
- Definition Classes
- Translations
- def isUnboundedGeneric(tp: Type): Boolean
- Definition Classes
- Types
- def isUseableAsTypeArg(tp: Type): Boolean
This is defined and named as it is because the goal is to exclude source level types which are not value types (e.g.
This is defined and named as it is because the goal is to exclude source level types which are not value types (e.g. MethodType) without excluding necessary internal types such as WildcardType. There are also non-value types which can be used as type arguments (e.g. type constructors.)
- Definition Classes
- Types
- final def isUseableAsTypeArgs(tps: List[Type]): Boolean
- Definition Classes
- Types
- Annotations
- @tailrec()
- final def isValid(period: Period): Boolean
- Definition Classes
- SymbolTable
- final def isValidForBaseClasses(period: Period): Boolean
- Definition Classes
- SymbolTable
- def isWeakSubType(tp1: Type, tp2: Type): Boolean
- Definition Classes
- TypeComparers
- def isWithinBounds(pre: Type, owner: Symbol, tparams: List[Symbol], targs: List[Type]): Boolean
Do type arguments
targs
conform to formal parameterstparams
?Do type arguments
targs
conform to formal parameterstparams
?- Definition Classes
- Types
- val javanme: JavaKeywords
- Definition Classes
- StdNames
- var keepPhaseStack: Boolean
- Definition Classes
- SymbolTable
- def kindsConform(tparams: List[Symbol], targs: List[Type], pre: Type, owner: Symbol): Boolean
- Definition Classes
- Kinds
- final def linkedMapFrom[A, A1 >: A, B](xs: List[A])(f: (A) => B): LinkedHashMap[A1, B]
- Definition Classes
- Collections
- def lockedCount: Int
- Definition Classes
- Symbols
- def lockedCount_=(i: Int): Unit
- Definition Classes
- Symbols
- def log(msg: => AnyRef): Unit
- Definition Classes
- JavaUniverse → SymbolTable
- final def lookupTypeName(cs: Array[Char]): TypeName
Used by the GenBCode backend to lookup type names that are known to already exist.
Used by the GenBCode backend to lookup type names that are known to already exist. This method might be invoked in a multi-threaded setting. Invoking newTypeName instead might be unsafe.
can-multi-thread: names are added to the hash tables only after they are fully constructed.
- Definition Classes
- Names
- implicit def lowPriorityNameOrdering[T <: Name]: Ordering[T]
- Definition Classes
- SymbolTable
- def lub(ts: List[Type], depth: Depth): Type
The least upper bound wrt <:< of a list of types
The least upper bound wrt <:< of a list of types
- Attributes
- protected[scala.reflect.internal]
- Definition Classes
- GlbLubs
- def lub(ts: List[Type]): Type
- Definition Classes
- GlbLubs
- def lubDepth(ts: List[Type]): Depth
The maximum allowable depth of lubs or glbs over types
ts
.The maximum allowable depth of lubs or glbs over types
ts
.- Definition Classes
- Types
- def lubList(ts: List[Type], depth: Depth): List[Type]
Given a matrix
tsBts
whose columns are basetype sequences (and the symbolstsParams
that should be interpreted as type parameters in this matrix), compute its least sorted upwards closed upper bound relative to the following ordering <= between lists of types:Given a matrix
tsBts
whose columns are basetype sequences (and the symbolstsParams
that should be interpreted as type parameters in this matrix), compute its least sorted upwards closed upper bound relative to the following ordering <= between lists of types:xs <= ys iff forall y in ys exists x in xs such that x <: y
- Definition Classes
- GlbLubs
- def lubResults: HashMap[(Depth, List[Type]), Type]
- Definition Classes
- SynchronizedTypes → GlbLubs
- def makeNoSymbol: NoSymbol
- Attributes
- protected
- Definition Classes
- SynchronizedSymbols → Symbols
- final def map2[A, B, C](xs1: List[A], xs2: List[B])(f: (A, B) => C): List[C]
- Definition Classes
- Collections
- final def map2Conserve[A <: AnyRef, B](xs: List[A], ys: List[B])(f: (A, B) => A): List[A]
like map2, but returns list
xs
itself - instead of a copy - if functionf
maps all elements to themselves.like map2, but returns list
xs
itself - instead of a copy - if functionf
maps all elements to themselves.- Definition Classes
- Collections
- final def map3[A, B, C, D](xs1: List[A], xs2: List[B], xs3: List[C])(f: (A, B, C) => D): List[D]
- Definition Classes
- Collections
- final def mapFilter2[A, B, C](itA: Iterator[A], itB: Iterator[B])(f: (A, B) => Option[C]): Iterator[C]
- Definition Classes
- Collections
- final def mapFrom[A, A1 >: A, B](xs: List[A])(f: (A) => B): Map[A1, B]
- Definition Classes
- Collections
- final def mapList[A, B](as: List[A])(f: (A) => B): List[B]
A version of List#map, specialized for List, and optimized to avoid allocation if
as
is emptyA version of List#map, specialized for List, and optimized to avoid allocation if
as
is empty- Definition Classes
- Collections
- def mapParamss[T](sym: Symbol)(f: (Symbol) => T): List[List[T]]
A deep map on a symbol's paramss.
A deep map on a symbol's paramss.
- Definition Classes
- Symbols
- final def mapWithIndex[A, B](xs: List[A])(f: (A, Int) => B): List[B]
- Definition Classes
- Collections
- final def markAllCompleted(sym1: Symbol, sym2: Symbol): Unit
- Definition Classes
- Symbols
- final def markAllCompleted(sym: Symbol): Unit
- Definition Classes
- Symbols
- final def markFlagsCompleted(sym1: Symbol, sym2: Symbol)(mask: Long): Unit
- Definition Classes
- Symbols
- final def markFlagsCompleted(sym: Symbol)(mask: Long): Unit
- Definition Classes
- Symbols
- final def matchesType(tp1: Type, tp2: Type, alwaysMatchSimple: Boolean): Boolean
A function implementing
tp1
matchestp2
.A function implementing
tp1
matchestp2
.- Definition Classes
- Types
- def matchingParams(syms1: List[Symbol], syms2: List[Symbol]): Boolean
Are
syms1
andsyms2
parameter lists with pairwise equivalent types?Are
syms1
andsyms2
parameter lists with pairwise equivalent types?- Attributes
- protected[scala.reflect.internal]
- Definition Classes
- Types
- final val maxToStringRecursions: Int(50)
The maximum number of recursions allowed in toString
The maximum number of recursions allowed in toString
- Definition Classes
- TypeToStrings
- def mergePrefixAndArgs(tps0: List[Type], variance: Variance, depth: Depth): Type
Compute lub (if
variance == Covariant
) or glb (ifvariance == Contravariant
) of given list of typestps
.Compute lub (if
variance == Covariant
) or glb (ifvariance == Contravariant
) of given list of typestps
. All types intps
are typerefs or singletypes with the same symbol. Returnx
if the computation succeeds with resultx
. ReturnNoType
if the computation fails.- Definition Classes
- Types
- final def mexists[A](xss: List[List[A]])(p: (A) => Boolean): Boolean
All these mm methods are "deep map" style methods for mapping etc.
All these mm methods are "deep map" style methods for mapping etc. on a list of lists while avoiding unnecessary intermediate structures like those created via flatten.
- Definition Classes
- Collections
- final def mfind[A](xss: List[List[A]])(p: (A) => Boolean): Option[A]
- Definition Classes
- Collections
- final def mforall[A](xss: List[List[A]])(p: (A) => Boolean): Boolean
- Definition Classes
- Collections
- final def mforeach[A](xss: Iterable[Iterable[A]])(f: (A) => Unit): Unit
- Definition Classes
- Collections
- final def mforeach[A](xss: List[List[A]])(f: (A) => Unit): Unit
These are all written in terms of List because we're trying to wring all the performance we can and List is used almost exclusively in the compiler, but people are branching out in their collections so here's an overload.
These are all written in terms of List because we're trying to wring all the performance we can and List is used almost exclusively in the compiler, but people are branching out in their collections so here's an overload.
- Definition Classes
- Collections
- def mirrorThatLoaded(sym: Symbol): Mirror
Returns the mirror that loaded given symbol
Returns the mirror that loaded given symbol
- Definition Classes
- JavaMirrors → SymbolTable
- val missingAliasException: MissingAliasControl
- Definition Classes
- Types
- def missingHook(owner: Symbol, name: Name): Symbol
1.
1. If
owner
is a package class (but not the empty package) andname
is a term name, make a new package <owner>.<name>, otherwise return NoSymbol. Exception: If owner is root and a java class with given name exists, create symbol in empty package instead 2. Ifowner
is the scala package andname
designates a phantom class, return the corresponding class symbol and enter it into this mirror's ScalaPackage.- Definition Classes
- JavaMirrors → SymbolTable
- def mkImporter(from0: Universe): Importer { val from: from0.type }
- Definition Classes
- Importers
- final def mkThreadLocalStorage[T](x: => T): ThreadLocalStorage[T]
- Definition Classes
- ThreadLocalStorage
- Annotations
- @inline()
- final def mmap[A, B](xss: List[List[A]])(f: (A) => B): collection.immutable.List[collection.immutable.List[B]]
- Definition Classes
- Collections
- final val nameDebug: Boolean(false)
- Definition Classes
- Names
- final def nameTableSize: Int
- Definition Classes
- Names
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def nestedMemberType(sym: Symbol, pre: Type, owner: Symbol): Type
A more persistent version of
Type#memberType
which does not require that the symbol is a direct member of the prefix.A more persistent version of
Type#memberType
which does not require that the symbol is a direct member of the prefix.For instance:
class C[T] { sealed trait F[A] object X { object S1 extends F[T] } class S2 extends F[T] } object O extends C[Int] { def foo(f: F[Int]) = f match {...} // need to enumerate sealed subtypes of the scrutinee here. } class S3 extends O.F[String] nestedMemberType(<S1>, <O.type>, <C>) = O.X.S1.type nestedMemberType(<S2>, <O.type>, <C>) = O.S2.type nestedMemberType(<S3>, <O.type>, <C>) = S3.type
- sym
The symbol of the subtype
- pre
The prefix from which the symbol is seen
- Definition Classes
- Types
- def newBaseTypeSeq(parents: List[Type], elems: Array[Type]): BaseTypeSeq
- Attributes
- protected
- Definition Classes
- SynchronizedOps → BaseTypeSeqs
- def newCodePrinter(writer: PrintWriter, tree: Tree, printRootPkg: Boolean): TreePrinter
Hook to define what
showCode(...)
means.Hook to define what
showCode(...)
means.- Definition Classes
- Printers → Printers
- def newDefDef(sym: Symbol, rhs: Tree)(mods: Modifiers = Modifiers(sym.flags), name: TermName = sym.name.toTermName, tparams: List[TypeDef] = sym.typeParams map TypeDef.apply, vparamss: List[List[ValDef]] = mapParamss(sym)(ValDef.apply), tpt: Tree = TypeTreeMemberType(sym)): DefDef
- Definition Classes
- Trees
- final def newExistentialType(quantified: List[Symbol], underlying: Type): Type
A creator for existential types which flattens nested existentials.
A creator for existential types which flattens nested existentials.
- Definition Classes
- Types
- Annotations
- @tailrec()
- def newFreeTermSymbol(name: TermName, value: => Any, flags: Long = 0L, origin: String = null): FreeTermSymbol
Create a new free term.
Create a new free term. Its owner is NoSymbol.
- Definition Classes
- SynchronizedSymbols → Symbols
- def newFreeTypeSymbol(name: TypeName, flags: Long = 0L, origin: String = null): FreeTypeSymbol
Create a new free type.
Create a new free type. Its owner is NoSymbol.
- Definition Classes
- SynchronizedSymbols → Symbols
- def newLazyTreeCopier: TreeCopier
Creates a lazy tree copier.
Creates a lazy tree copier.
- Definition Classes
- JavaUniverse → Trees
- def newMappedBaseTypeSeq(orig: BaseTypeSeq, f: (Type) => Type): MappedBaseTypeSeq with SynchronizedBaseTypeSeq
- Attributes
- protected
- Definition Classes
- SynchronizedOps → BaseTypeSeqs
- final def newNestedScope(outer: Scope): Scope
Create a new scope nested in another one with which it shares its elements
Create a new scope nested in another one with which it shares its elements
- Definition Classes
- Scopes
- def newPackageScope(pkgClass: Symbol): PackageScope
- Definition Classes
- SymbolLoaders
- def newRawTreePrinter(writer: PrintWriter): RawTreePrinter
Hook to define what
showRaw(...)
means.Hook to define what
showRaw(...)
means.- Definition Classes
- Printers → Printers
- def newScope: Scope with SynchronizedScope
Create a new scope
Create a new scope
- Definition Classes
- SynchronizedOps → Scopes
- def newScopeWith(elems: Symbol*): Scope
Create a new scope with given initial elements
Create a new scope with given initial elements
- Definition Classes
- Scopes
- def newStrictTreeCopier: TreeCopier
Creates a strict tree copier.
Creates a strict tree copier.
- Definition Classes
- JavaUniverse → Trees
- def newStubSymbol(owner: Symbol, name: Name, missingMessage: String): Symbol
- Attributes
- protected
- Definition Classes
- Symbols
- final def newTermName(bs: Array[Byte], offset: Int, len: Int): TermName
Create a term name from the UTF8 encoded bytes in bs[offset..offset+len-1].
Create a term name from the UTF8 encoded bytes in bs[offset..offset+len-1].
- Definition Classes
- Names
- def newTermName(s: String): TermName
Create a term name from string.
Create a term name from string.
- Definition Classes
- Names → Names
- Annotations
- @deprecatedOverriding("To synchronize, use `override def synchronizeNames = true`", "2.11.0")
- final def newTermName(cs: Array[Char], offset: Int, len0: Int, cachedString: String): TermName
Create a term name from the characters in cs[offset..offset+len-1].
Create a term name from the characters in cs[offset..offset+len-1]. TODO - have a mode where name validation is performed at creation time (e.g. if a name has the string "$class" in it, then fail if that string is not at the very end.)
- len0
the length of the name. Negative lengths result in empty names.
- Definition Classes
- Names
- final def newTermName(cs: Array[Char]): TermName
- Definition Classes
- Names
- final def newTermName(cs: Array[Char], offset: Int, len: Int): TermName
Create a term name from the characters in cs[offset..offset+len-1].
Create a term name from the characters in cs[offset..offset+len-1].
- Definition Classes
- Names
- final def newTermNameCached(s: String): TermName
- Definition Classes
- Names
- def newTreePrinter(): TreePrinter
- Definition Classes
- Printers
- def newTreePrinter(stream: OutputStream): TreePrinter
- Definition Classes
- Printers
- def newTreePrinter(writer: PrintWriter): TreePrinter
Hook to define what
show(...)
means.Hook to define what
show(...)
means.- Definition Classes
- Printers → Printers
- def newTypeDef(sym: Symbol, rhs: Tree)(mods: Modifiers = Modifiers(sym.flags), name: TypeName = sym.name.toTypeName, tparams: List[TypeDef] = sym.typeParams map TypeDef.apply): TypeDef
- Definition Classes
- Trees
- final def newTypeName(bs: Array[Byte], offset: Int, len: Int): TypeName
Create a type name from the UTF8 encoded bytes in bs[offset..offset+len-1].
Create a type name from the UTF8 encoded bytes in bs[offset..offset+len-1].
- Definition Classes
- Names
- final def newTypeName(cs: Array[Char], offset: Int, len: Int): TypeName
Create a type name from the characters in cs[offset..offset+len-1].
Create a type name from the characters in cs[offset..offset+len-1].
- Definition Classes
- Names
- def newTypeName(s: String): TypeName
Create a type name from string.
Create a type name from string.
- Definition Classes
- Names → Names
- Annotations
- @deprecatedOverriding("To synchronize, use `override def synchronizeNames = true`", "2.11.0")
- final def newTypeName(cs: Array[Char], offset: Int, len: Int, cachedString: String): TypeName
- Definition Classes
- Names
- final def newTypeName(cs: Array[Char]): TypeName
- Definition Classes
- Names
- final def newTypeNameCached(s: String): TypeName
- Definition Classes
- Names
- def newValDef(sym: Symbol, rhs: Tree)(mods: Modifiers = Modifiers(sym.flags), name: TermName = sym.name.toTermName, tpt: Tree = TypeTreeMemberType(sym)): ValDef
- Definition Classes
- Trees
- var nextFrom: Array[InfoTransformer]
- Definition Classes
- SymbolTable
- def nextId(): Int
- Attributes
- protected
- Definition Classes
- SynchronizedSymbols → Symbols
- def nonTrivialMembers(clazz: Symbol): Scope
Members of the given class, other than those inherited from Any or AnyRef.
Members of the given class, other than those inherited from Any or AnyRef.
- Definition Classes
- Types
- final def normalizePlus(tp: Type): Type
- Definition Classes
- Types
- Annotations
- @tailrec()
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def numericLub(ts: List[Type]): Type
- Definition Classes
- GlbLubs
- def openPackageModule(pkgClass: Symbol): Unit
if there's a
package
member object inpkgClass
, enter its members into it.if there's a
package
member object inpkgClass
, enter its members into it.- Definition Classes
- SymbolTable
- def openPackageModule(container: Symbol, dest: Symbol): Unit
- Definition Classes
- SymbolTable
- def overloadedType(pre: Type, alternatives: List[Symbol]): Type
The canonical creator for OverloadedTypes.
The canonical creator for OverloadedTypes.
- Definition Classes
- Types
- final def packSymbols(hidden: List[Symbol], tp: Type, rawOwner: Symbol = NoSymbol): Type
Compute an existential type from hidden symbols
hidden
and typetp
.Compute an existential type from hidden symbols
hidden
and typetp
.- hidden
The symbols that will be existentially abstracted
- tp
The original type
- rawOwner
The owner for Java raw types.
- Definition Classes
- ExistentialsAndSkolems
- def paramString(tp: Type): String
- Definition Classes
- TypeDebugging
- final def partitionInto[A](xs: List[A], pred: (A) => Boolean, ayes: ListBuffer[A], nays: ListBuffer[A]): Unit
- Definition Classes
- Collections
- def pendingBaseTypes: HashSet[Type]
- Definition Classes
- SynchronizedTypes → Types
- def pendingSubTypes: HashSet[SubTypePair]
- Definition Classes
- SynchronizedTypes → TypeComparers
- final def period(rid: RunId, pid: Int): Period
- Definition Classes
- SymbolTable
- final def phase: Phase
- Definition Classes
- SymbolTable
- final def phaseId(period: Period): Int
The phase identifier of the given period.
The phase identifier of the given period.
- Definition Classes
- SymbolTable
- final def phaseOf(period: Period): Phase
The phase associated with given period.
The phase associated with given period.
- Definition Classes
- SymbolTable
- val phaseWithId: Array[Phase]
The phase which has given index as identifier.
The phase which has given index as identifier.
- Definition Classes
- ReflectSetup → SymbolTable
- final def phase_=(p: Phase): Unit
- Definition Classes
- SymbolTable
- def picklerPhase: SomePhase
- Definition Classes
- JavaUniverse → SymbolTable
- def picklerSubTag(tree: Tree): Int
- Definition Classes
- Translations
- final def picklerTag(tpe: Type): Int
- Definition Classes
- Translations
- Annotations
- @tailrec()
- def picklerTag(sym: Symbol): Int
Local symbols only.
Local symbols only. The assessment of locality depends on convoluted conditions which depends in part on the root symbol being pickled, so it cannot be reproduced here. The pickler tags at stake are EXTMODCLASSref and EXTref. Those tags are never produced here - such symbols must be excluded prior to calling this method.
- Definition Classes
- Translations
- final def picklerTag(ref: AnyRef): Int
- Definition Classes
- Translations
- final def popPhase(ph: Phase): Unit
- Definition Classes
- SymbolTable
- lazy val posAssigner: PosAssigner
- Attributes
- protected[this]
- Definition Classes
- Positions
- def postErasure: PostErasure { val global: JavaUniverse.this.type }
- Definition Classes
- Transforms
- def propagatePackageBoundary(jflags: JavaAccFlags, syms: Symbol*): Unit
- Definition Classes
- PrivateWithin
- def propagatePackageBoundary(m: Member, syms: Symbol*): Unit
- Definition Classes
- PrivateWithin
- def propagatePackageBoundary(c: Class[_], syms: Symbol*): Unit
- Definition Classes
- PrivateWithin
- final def pushPhase(ph: Phase): Phase
- Definition Classes
- SymbolTable
- def quotedName(name: String): String
- Definition Classes
- Printers
- def quotedName(name: Name): String
- Definition Classes
- Printers
- def quotedName(name: Name, decode: Boolean): String
Adds backticks if the name is a scala keyword.
Adds backticks if the name is a scala keyword.
- Definition Classes
- Printers
- def rangePos(source: SourceFile, start: Int, point: Int, end: Int): Position
- Definition Classes
- Positions
- def rawToExistential: TypeMap
The raw to existential map converts a raw type to an existential type.
The raw to existential map converts a raw type to an existential type. It is necessary because we might have read a raw type of a parameterized Java class from a class file. At the time we read the type the corresponding class file might still not be read, so we do not know what the type parameters of the type are. Therefore the conversion of raw types to existential types might not have taken place in ClassFileParser.sigToType (where it is usually done).
- Definition Classes
- TypeMaps
- def recursionTable: Map[Symbol, Int]
- Definition Classes
- SynchronizedSymbols → Symbols
- def recursionTable_=(value: Map[Symbol, Int]): Unit
- Definition Classes
- SynchronizedSymbols → Symbols
- def referenceCapturedVariable(vble: Symbol): Tree
Mark given identifier as a reference to a captured variable itself suppressing dereferencing with the
elem
field.Mark given identifier as a reference to a captured variable itself suppressing dereferencing with the
elem
field.- Definition Classes
- CapturedVariables
- def refinedType(parents: List[Type], owner: Symbol): Type
The canonical creator for a refined type with an initially empty scope.
The canonical creator for a refined type with an initially empty scope.
- Definition Classes
- Types
- def refinedType(parents: List[Type], owner: Symbol, decls: Scope, pos: Position): Type
the canonical creator for a refined type with a given scope
the canonical creator for a refined type with a given scope
- Definition Classes
- Types
- 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 removeAllAnnotationCheckers(): Unit
Remove all annotation checkers
Remove all annotation checkers
- Definition Classes
- AnnotationCheckers
- def render(what: Any, mkPrinter: (PrintWriter) => JavaUniverse.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 repackExistential(tp: Type): Type
Repack existential types, otherwise they sometimes get unpacked in the wrong location (type inference comes up with an unexpected skolem)
Repack existential types, otherwise they sometimes get unpacked in the wrong location (type inference comes up with an unexpected skolem)
- Definition Classes
- Types
- def reporter: Reporter
- Definition Classes
- JavaUniverse → Reporting
- final def require(requirement: Boolean, message: => Any): Unit
- Definition Classes
- SymbolTable
- Annotations
- @inline()
- def rootClassLoader: ClassLoader
- Definition Classes
- JavaMirrors
- lazy 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
- JavaMirrors → Mirrors
- final def runId(period: Period): RunId
The run identifier of the given period.
The run identifier of the given period.
- Definition Classes
- SymbolTable
- 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- Definition Classes
- JavaMirrors → JavaUniverse
- final def sameElementsEquals(thiss: List[AnyRef], that: List[AnyRef]): Boolean
- Definition Classes
- Collections
- final def sameLength(xs1: List[_], xs2: List[_]): Boolean
True if two lists have the same length.
True if two lists have the same length. Since calling length on linear sequences is O(n), it is an inadvisable way to test length equality.
- Definition Classes
- Collections
- def sameWeakLubAsLub(tps: List[Type]): Boolean
Does this set of types have the same weak lub as it does regular lub? This is exposed so lub callers can discover whether the trees they are typing will may require further adaptation.
Does this set of types have the same weak lub as it does regular lub? This is exposed so lub callers can discover whether the trees they are typing will may require further adaptation. It may return false negatives, but it will not return false positives.
- Definition Classes
- GlbLubs
- def saveOriginalOwner(sym: Symbol): Unit
- Attributes
- protected
- Definition Classes
- Symbols
- def scopeTransform(owner: Symbol)(op: => Scope): Scope
- Definition Classes
- SymbolLoaders
- final def sequenceOpt[A](as: List[Option[A]]): Option[List[A]]
- Definition Classes
- Collections
- def setAllInfos(clazz: Symbol, module: Symbol, info: Type): Unit
- Attributes
- protected
- Definition Classes
- SymbolLoaders
- def setPackageAccessBoundary(sym: Symbol): Symbol
- Definition Classes
- PrivateWithin
- lazy val settings: Settings
- Definition Classes
- JavaUniverse → SymbolTable
- val shorthands: Set[String]
- Definition Classes
- Types
- def shouldLogAtThisPhase: Boolean
- Definition Classes
- SymbolTable
- def show(position: Position): String
Renders a prettified representation of a position.
Renders a prettified representation of a position.
- Definition Classes
- Printers → Printers
- def show(flags: FlagSet): String
Renders a prettified representation of a flag set.
Renders a prettified representation of a flag set.
- Definition Classes
- Printers → Printers
- def show(name: Name): String
Renders a prettified representation of a name.
Renders a prettified representation of a name.
- Definition Classes
- Printers → 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 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 → 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
- def singleType(pre: Type, sym: Symbol): Type
The canonical creator for single-types
The canonical creator for single-types
- Definition Classes
- Types
- def singletonBounds(hi: Type): TypeBounds
- Definition Classes
- Types
- def skipPrefixOf(pre: Type, clazz: Symbol): Boolean
- Attributes
- protected[scala.reflect.internal]
- Definition Classes
- TypeMaps
- def skolemizationLevel: Int
- Definition Classes
- SynchronizedTypes → Types
- def skolemizationLevel_=(value: Int): Unit
- Definition Classes
- SynchronizedTypes → Types
- def slowButSafeEnteringPhase[T](ph: Phase)(op: => T): T
- Definition Classes
- SymbolTable
- def slowButSafeEnteringPhaseNotLaterThan[T](target: Phase)(op: => T): T
- Definition Classes
- SymbolTable
- lazy val sn: SymbolNames
- Definition Classes
- StdNames
- def solve(tvars: List[TypeVar], tparams: List[Symbol], getVariance: Extractor[Symbol], upper: Boolean, depth: Depth): Boolean
Solve constraint collected in types
tvars
.Solve constraint collected in types
tvars
.- tvars
All type variables to be instantiated.
- tparams
The type parameters corresponding to
tvars
- getVariance
Function to extract variances of type parameters; we need to reverse solution direction for all contravariant variables.
- upper
When
true
search for max solution else min.
- Definition Classes
- TypeConstraints
- def spanningTypes(ts: List[Type]): List[Type]
A minimal type list which has a given list of types as its base type sequence
A minimal type list which has a given list of types as its base type sequence
- Definition Classes
- GlbLubs
- def specializesSym(preLo: Type, symLo: Symbol, preHi: Type, symHi: Symbol, depth: Depth): Boolean
Does member
symLo
oftpLo
have a stronger type than membersymHi
oftpHi
?Does member
symLo
oftpLo
have a stronger type than membersymHi
oftpHi
?- Attributes
- protected[scala.reflect.internal]
- Definition Classes
- Types
- def specializesSym(tp: Type, sym: Symbol, depth: Depth): Boolean
- Definition Classes
- Types
- final val statistics: Statistics with ReflectStats
Some statistics (normally disabled) set with -Ystatistics
Some statistics (normally disabled) set with -Ystatistics
- Definition Classes
- JavaUniverse → SymbolTable
- final def stripExistentialsAndTypeVars(ts: List[Type], expandLazyBaseType: Boolean = false): (List[Type], List[Symbol])
- Definition Classes
- Types
- def subsametypeRecursions: Int
- Definition Classes
- SynchronizedTypes → TypeComparers
- def subsametypeRecursions_=(value: Int): Unit
- Definition Classes
- SynchronizedTypes → TypeComparers
- final def sumSize(xss: List[List[_]], acc: Int): Int
- Definition Classes
- Collections
- Annotations
- @tailrec()
- def supplementErrorMessage(errorMessage: String): String
- Definition Classes
- Reporting
- def supplementTyperState(errorMessage: String): String
- Definition Classes
- Reporting
- final def suspendingTypeVars[T](tvs: List[TypeVar])(op: => T): T
- Definition Classes
- Types
- Annotations
- @inline()
- def symName(tree: Tree, name: Name): String
- Definition Classes
- Printers
- def symbolOf[T](implicit arg0: WeakTypeTag[T]): TypeSymbol
- Definition Classes
- Symbols
- def synchronizeNames: Boolean
- Attributes
- protected
- Definition Classes
- SynchronizedOps → Names
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- lazy val termNames: nme.type
- Definition Classes
- StdNames
- def throwableAsString(t: Throwable, maxFrames: Int): String
- Definition Classes
- SymbolTable
- def throwableAsString(t: Throwable): String
- Definition Classes
- SymbolTable
- def toString(): String
- Definition Classes
- AnyRef → Any
- def toStringRecursions: Int
- Definition Classes
- SynchronizedTypes → TypeToStrings
- def toStringRecursions_=(value: Int): Unit
- Definition Classes
- SynchronizedTypes → TypeToStrings
- def toStringSubjects: HashSet[Type]
- Definition Classes
- SynchronizedTypes → TypeToStrings
- final val traceSymbolActivity: Boolean
Dump each symbol to stdout after shutdown.
Dump each symbol to stdout after shutdown.
- Definition Classes
- SymbolTable
- def transformedType(tpe: Type): Type forSome {val _1: PostErasure { val global: JavaUniverse.this.type }}
- Definition Classes
- Transforms
- def transformedType(sym: Symbol): Type forSome {val stabilizer$1: PostErasure { val global: JavaUniverse.this.type }}
- Definition Classes
- Transforms
- def transparentShallowTransform(container: Symbol, tp: Type)(f: (Type) => Type): Type
- Definition Classes
- Types
- final def transposeSafe[A](ass: List[List[A]]): Option[List[List[A]]]
- Definition Classes
- Collections
- final def traverseOpt[A, B](as: List[A])(f: (A) => Option[B]): Option[List[B]]
- Definition Classes
- Collections
- lazy val treeBuild: TreeGen
- Definition Classes
- Internals
- val treeCopy: TreeCopier
The standard (lazy) tree copier.
The standard (lazy) tree copier.
- Definition Classes
- Trees
- def treeLine(t: Tree): String
- Attributes
- protected
- Definition Classes
- Trees
- def treeStatus(t: Tree, enclosingTree: Tree = null): String
- Attributes
- protected
- Definition Classes
- Trees
- def treeSymStatus(t: Tree): String
- Attributes
- protected
- Definition Classes
- Trees
- def treeToAnnotation(tree: Tree): Annotation
- Attributes
- protected[scala]
- Definition Classes
- AnnotationInfos → Annotations
- def treeToString(tree: Tree): String
By default trees are printed with
show
By default trees are printed with
show
- Attributes
- protected
- Definition Classes
- Printers
- final def typeDepth(tp: Type): Depth
The maximum depth of type
tp
The maximum depth of type
tp
- Definition Classes
- Types
- def typeFun(tps: List[Symbol], body: Type): Type
A creator for a type functions, assuming the type parameters tps already have the right owner.
A creator for a type functions, assuming the type parameters tps already have the right owner.
- Definition Classes
- Types
- lazy val typeNames: tpnme.type
- Definition Classes
- StdNames
- def typeOf[T](implicit ttag: TypeTag[T]): Type
Shortcut for
implicitly[TypeTag[T]].tpe
Shortcut for
implicitly[TypeTag[T]].tpe
- Definition Classes
- TypeTags
- def typeParamsString(tp: Type): String
- Definition Classes
- TypeDebugging
- def typeParamsToExistentials(clazz: Symbol): List[Symbol]
- Definition Classes
- Types
- def typeParamsToExistentials(clazz: Symbol, tparams: List[Symbol]): List[Symbol]
- Definition Classes
- Types
- final def typeRef(pre: Type, sym: Symbol, args: List[Type]): Type
The canonical creator for typerefs todo: see how we can clean this up a bit
The canonical creator for typerefs todo: see how we can clean this up a bit
- Definition Classes
- Types
- Annotations
- @tailrec()
- def typeTag[T](implicit ttag: TypeTag[T]): TypeTag[T]
Shortcut for
implicitly[TypeTag[T]]
Shortcut for
implicitly[TypeTag[T]]
- Definition Classes
- TypeTags
- def typeToString(tpe: Type): String
- Attributes
- protected
- Definition Classes
- TypeToStrings
- def typeTreeSymbol(tree: TypeTree): Symbol
Delegate for a TypeTree symbol.
Delegate for a TypeTree symbol. This operation is unsafe because it may trigger type checking when forcing the type symbol of the underlying type.
- Attributes
- protected
- Definition Classes
- Trees
- def typeVarsInType(tp: Type): List[TypeVar]
A list of the typevars in a type.
A list of the typevars in a type.
- Definition Classes
- Types
- final def uncheckedBounds(tp: Type): Type
Adds the @uncheckedBound annotation if the given
tp
has type argumentsAdds the @uncheckedBound annotation if the given
tp
has type arguments- Definition Classes
- Types
- def uncurry: UnCurry { val global: JavaUniverse.this.type }
- Definition Classes
- Transforms
- lazy val undetBaseTypeSeq: BaseTypeSeq
A marker object for a base type sequence that's no yet computed.
A marker object for a base type sequence that's no yet computed. used to catch inheritance cycles
- Definition Classes
- BaseTypeSeqs
- def undoLog: UndoLog
- Definition Classes
- SynchronizedTypes → TypeConstraints
- def unique[T <: Type](tp: T): T
- Definition Classes
- SynchronizedTypes → Types
- def useOffsetPositions: Boolean
- Definition Classes
- Positions
- def validateClassInfo(tp: ClassInfoType): Unit
Assert that packages have package scopes
Assert that packages have package scopes
- Definition Classes
- SymbolLoaders
- def validatePositions(tree: Tree): Unit
- Definition Classes
- Positions
- final def varianceInType(tp: Type)(tparam: Symbol): Variance
Compute variance of type parameter
tparam
in typetp
.Compute variance of type parameter
tparam
in typetp
.- Definition Classes
- Variances
- final def varianceInTypes(tps: List[Type])(tparam: Symbol): Variance
Compute variance of type parameter
tparam
in all typestps
.Compute variance of type parameter
tparam
in all typestps
.- Definition Classes
- Variances
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- def warning(pos: Position, msg: String): Unit
- Definition Classes
- Reporting
- Annotations
- @deprecatedOverriding("This forwards to the corresponding method in reporter -- override reporter instead", "2.11.2")
- def warning(msg: String): Unit
- Definition Classes
- Reporting
- Annotations
- @deprecatedOverriding("This forwards to the corresponding method in reporter -- override reporter instead", "2.11.2")
- def weakLub(tps: List[Type]): Type
If the arguments are all numeric value types, the numeric lub according to the weak conformance spec.
If the arguments are all numeric value types, the numeric lub according to the weak conformance spec. If any argument has type annotations, take the lub of the unannotated type and call the analyzerPlugin method annotationsLub so it can be further altered. Otherwise, the regular lub.
- Definition Classes
- GlbLubs
- 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 withTypesExplained[A](op: => A): A
Execute
op
while printing a trace of the operations on types executed.Execute
op
while printing a trace of the operations on types executed.- Definition Classes
- Types
- def wrappingIntoTerm(tree0: Tree)(op: (Tree) => Tree): Tree
- Definition Classes
- Trees
- 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 some of 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 → Positions
- def wrappingPos(default: Position, trees: List[Tree], focus: Boolean): Position
- Definition Classes
- Positions
- 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 that is either focused or not.
- Definition Classes
- Positions → Positions
- def xprintTree(treePrinter: TreePrinter, tree: Tree): Unit
Hook for extensions
Hook for extensions
- Definition Classes
- Printers
- 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
- object Alternative extends internal.SymbolTable.AlternativeExtractor with java.io.Serializable
The constructor/extractor for
Alternative
instances.The constructor/extractor for
Alternative
instances.- Definition Classes
- Trees → Trees
- object Annotated extends internal.SymbolTable.AnnotatedExtractor with java.io.Serializable
The constructor/extractor for
Annotated
instances.The constructor/extractor for
Annotated
instances.- Definition Classes
- Trees → Trees
- object AnnotatedType extends internal.SymbolTable.AnnotatedTypeExtractor with java.io.Serializable
The constructor/extractor for
AnnotatedType
instances.The constructor/extractor for
AnnotatedType
instances.- Definition Classes
- Types → Types
- object Annotation extends internal.SymbolTable.AnnotationExtractor
The constructor/extractor for
Annotation
instances.The constructor/extractor for
Annotation
instances.- Definition Classes
- AnnotationInfos → Annotations
- object AnnotationInfo
- Definition Classes
- AnnotationInfos
- object AppliedTypeTree extends internal.SymbolTable.AppliedTypeTreeExtractor with java.io.Serializable
The constructor/extractor for
AppliedTypeTree
instances.The constructor/extractor for
AppliedTypeTree
instances.- Definition Classes
- Trees → Trees
- object Apply extends internal.SymbolTable.ApplyExtractor with java.io.Serializable
The constructor/extractor for
Apply
instances.The constructor/extractor for
Apply
instances.- Definition Classes
- Trees → Trees
- object ApproximateDependentMap extends internal.SymbolTable.TypeMap
- Definition Classes
- TypeMaps
- object ArrayTypeRef
- Definition Classes
- Types
- object Assign extends internal.SymbolTable.AssignExtractor with java.io.Serializable
The constructor/extractor for
Assign
instances.The constructor/extractor for
Assign
instances.- Definition Classes
- Trees → Trees
- object BackquotedIdentifierAttachment extends internal.SymbolTable.PlainAttachment with Product with Serializable
When present, indicates that the host
Ident
has been created from a backquoted identifier.When present, indicates that the host
Ident
has been created from a backquoted identifier.- Definition Classes
- StdAttachments
- object Bind extends internal.SymbolTable.BindExtractor with java.io.Serializable
The constructor/extractor for
Bind
instances.The constructor/extractor for
Bind
instances.- Definition Classes
- Trees → Trees
- object Block extends internal.SymbolTable.BlockExtractor with java.io.Serializable
The constructor/extractor for
Block
instances.The constructor/extractor for
Block
instances.- Definition Classes
- Trees → Trees
- object BoundedWildcardType extends internal.SymbolTable.BoundedWildcardTypeExtractor with java.io.Serializable
The constructor/extractor for
BoundedWildcardType
instances.The constructor/extractor for
BoundedWildcardType
instances.- Definition Classes
- Types → Types
- object CaseDef extends internal.SymbolTable.CaseDefExtractor with java.io.Serializable
The constructor/extractor for
CaseDef
instances.The constructor/extractor for
CaseDef
instances.- Definition Classes
- Trees → Trees
- object ClassDef extends internal.SymbolTable.ClassDefExtractor with java.io.Serializable
The constructor/extractor for
ClassDef
instances.The constructor/extractor for
ClassDef
instances.- Definition Classes
- Trees → Trees
- object ClassInfoType extends internal.SymbolTable.ClassInfoTypeExtractor with java.io.Serializable
The constructor/extractor for
ClassInfoType
instances.The constructor/extractor for
ClassInfoType
instances.- Definition Classes
- Types → Types
- object CompoundType
- Definition Classes
- Types
- object CompoundTypeTree extends internal.SymbolTable.CompoundTypeTreeExtractor with java.io.Serializable
The constructor/extractor for
CompoundTypeTree
instances.The constructor/extractor for
CompoundTypeTree
instances.- Definition Classes
- Trees → Trees
- object ConsoleWriter extends Writer
A writer that writes to the current Console and is sensitive to replacement of the Console's output stream.
A writer that writes to the current Console and is sensitive to replacement of the Console's output stream.
- Definition Classes
- Printers
- object Constant extends internal.SymbolTable.ConstantExtractor with java.io.Serializable
The constructor/extractor for
Constant
instances.The constructor/extractor for
Constant
instances.- Definition Classes
- Constants → Constants
- object ConstantType extends internal.SymbolTable.ConstantTypeExtractor
The constructor/extractor for
ConstantType
instances.The constructor/extractor for
ConstantType
instances.- Definition Classes
- Types → Types
- object ConstructorNeedsFence extends internal.SymbolTable.PlainAttachment with Product with Serializable
- Definition Classes
- StdAttachments
- object DefDef extends internal.SymbolTable.DefDefExtractor with java.io.Serializable
The constructor/extractor for
DefDef
instances.The constructor/extractor for
DefDef
instances.- Definition Classes
- Trees → Trees
- object DelambdafyTarget extends internal.SymbolTable.PlainAttachment with Product with Serializable
- Definition Classes
- StdAttachments
- object EmptyScope extends internal.SymbolTable.Scope
The empty scope (immutable).
The empty scope (immutable).
- Definition Classes
- Scopes
- object EmptyTree extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.CannotHaveAttrs with Product with Serializable
The empty tree
The empty tree
- Definition Classes
- Trees → Trees
- object ErasedValueType extends java.io.Serializable
- Definition Classes
- Types
- object ErroneousCollector extends internal.SymbolTable.TypeCollector[Boolean]
- Definition Classes
- TypeMaps
- object ErrorType extends internal.SymbolTable.Type with Product with Serializable
An object representing an erroneous type
An object representing an erroneous type
- Definition Classes
- Types
- object ExistentialType extends internal.SymbolTable.ExistentialTypeExtractor with java.io.Serializable
The constructor/extractor for
ExistentialType
instances.The constructor/extractor for
ExistentialType
instances.- Definition Classes
- Types → Types
- object ExistentialTypeTree extends internal.SymbolTable.ExistentialTypeTreeExtractor with java.io.Serializable
The constructor/extractor for
ExistentialTypeTree
instances.The constructor/extractor for
ExistentialTypeTree
instances.- Definition Classes
- Trees → Trees
- object Flag extends internal.SymbolTable.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 → FlagSets
- object FoldableConstantType extends java.io.Serializable
- Definition Classes
- Types
- object ForAttachment extends internal.SymbolTable.PlainAttachment with Product with Serializable
Identifies trees are either result or intermediate value of for loop desugaring.
Identifies trees are either result or intermediate value of for loop desugaring.
- Definition Classes
- StdAttachments
- object Function extends internal.SymbolTable.FunctionExtractor with java.io.Serializable
The constructor/extractor for
Function
instances.The constructor/extractor for
Function
instances.- Definition Classes
- Trees → Trees
- object GenPolyType
A creator and extractor for type parameterizations that strips empty type parameter lists.
A creator and extractor for type parameterizations that strips empty type parameter lists. Use this factory method to indicate the type has kind * (it's a polymorphic value)
- Definition Classes
- Types
- object HasTypeMember
- Definition Classes
- Types
- object Ident extends internal.SymbolTable.IdentExtractor with java.io.Serializable
The constructor/extractor for
Ident
instances.The constructor/extractor for
Ident
instances.- Definition Classes
- Trees → Trees
- object If extends internal.SymbolTable.IfExtractor with java.io.Serializable
The constructor/extractor for
If
instances.The constructor/extractor for
If
instances.- Definition Classes
- Trees → Trees
- object Import extends internal.SymbolTable.ImportExtractor with java.io.Serializable
The constructor/extractor for
Import
instances.The constructor/extractor for
Import
instances.- Definition Classes
- Trees → Trees
- object ImportSelector extends internal.SymbolTable.ImportSelectorExtractor with java.io.Serializable
The constructor/extractor for
ImportSelector
instances.The constructor/extractor for
ImportSelector
instances.- Definition Classes
- Trees → Trees
- object InlineCallsiteAttachment extends internal.SymbolTable.InlineAnnotatedAttachment with Product with Serializable
- Definition Classes
- StdAttachments
- object IsDependentCollector extends internal.SymbolTable.TypeCollector[Boolean]
- Definition Classes
- TypeMaps
- object Kind
- Definition Classes
- Kinds
- object KnownDirectSubclassesCalled extends internal.SymbolTable.PlainAttachment with Product with Serializable
Attached to a class symbol to indicate that its children have been observed via knownDirectSubclasses.
Attached to a class symbol to indicate that its children have been observed via knownDirectSubclasses. Children added subsequently will trigger an error to indicate that the earlier observation was incomplete.
- Definition Classes
- StdAttachments
- object LabelDef extends internal.SymbolTable.LabelDefExtractor with java.io.Serializable
The constructor/extractor for
LabelDef
instances.The constructor/extractor for
LabelDef
instances.- Definition Classes
- Trees → Trees
- object Literal extends internal.SymbolTable.LiteralExtractor with java.io.Serializable
The constructor/extractor for
Literal
instances.The constructor/extractor for
Literal
instances.- Definition Classes
- Trees → Trees
- object LiteralType extends java.io.Serializable
- Definition Classes
- Types
- object LookupNotFound extends internal.SymbolTable.NameLookup with Product with Serializable
- Definition Classes
- Scopes
- object Match extends internal.SymbolTable.MatchExtractor with java.io.Serializable
The constructor/extractor for
Match
instances.The constructor/extractor for
Match
instances.- Definition Classes
- Trees → Trees
- object MethodType extends internal.SymbolTable.MethodTypeExtractor with java.io.Serializable
The constructor/extractor for
MethodType
instances.The constructor/extractor for
MethodType
instances.- Definition Classes
- Types → Types
- object MethodValue
- Definition Classes
- Trees
- object Modifiers extends internal.SymbolTable.ModifiersExtractor with java.io.Serializable
The constructor/extractor for
Modifiers
instances.The constructor/extractor for
Modifiers
instances.- Definition Classes
- Trees → Trees
- object ModuleDef extends internal.SymbolTable.ModuleDefExtractor with java.io.Serializable
The constructor/extractor for
ModuleDef
instances.The constructor/extractor for
ModuleDef
instances.- Definition Classes
- Trees → Trees
- object NamedArg extends internal.SymbolTable.NamedArgExtractor with java.io.Serializable
The constructor/extractor for
NamedArg
instances.The constructor/extractor for
NamedArg
instances.- Definition Classes
- Trees → Trees
- object New extends internal.SymbolTable.NewExtractor with java.io.Serializable
The constructor/extractor for
New
instances.The constructor/extractor for
New
instances.- Definition Classes
- Trees → Trees
- object NoInlineCallsiteAttachment extends internal.SymbolTable.InlineAnnotatedAttachment with Product with Serializable
- Definition Classes
- StdAttachments
- object NoPrefix extends internal.SymbolTable.Type with Product with Serializable
An object representing a non-existing prefix
An object representing a non-existing prefix
- Definition Classes
- Types → Types
- object NoType extends internal.SymbolTable.Type with Product with Serializable
An object representing a non-existing type
An object representing a non-existing type
- Definition Classes
- Types → Types
- object NoWarnAttachment extends internal.SymbolTable.PlainAttachment with Product with Serializable
A pattern binding exempt from unused warning.
A pattern binding exempt from unused warning.
Its host
Ident
has been created from a pattern2 binding,case x @ p
. In the absence of named parameters in patterns, allows nuanced warnings for unused variables. Hence,case X(x = _) =>
would not warn; for now,case X(x @ _) =>
is documentary if x is unused.- Definition Classes
- StdAttachments
- object NullaryMethodType extends internal.SymbolTable.NullaryMethodTypeExtractor with java.io.Serializable
The constructor/extractor for
NullaryMethodType
instances.The constructor/extractor for
NullaryMethodType
instances.- Definition Classes
- Types → Types
- object OuterArgCanBeElided extends internal.SymbolTable.PlainAttachment with Product with Serializable
Attached to a local class that has its outer field elided.
Attached to a local class that has its outer field elided. A
null
constant may be passed in place of the outer parameter, can help callers to avoid capturing the outer instance.- Definition Classes
- StdAttachments
- object PackageDef extends internal.SymbolTable.PackageDefExtractor with java.io.Serializable
The constructor/extractor for
PackageDef
instances.The constructor/extractor for
PackageDef
instances.- Definition Classes
- Trees → Trees
- object PatVarDefAttachment extends internal.SymbolTable.PlainAttachment with Product with Serializable
Indicates that a
ValDef
was synthesized from a pattern definition,val P(x)
.Indicates that a
ValDef
was synthesized from a pattern definition,val P(x)
.- Definition Classes
- StdAttachments
- object PolyType extends internal.SymbolTable.PolyTypeExtractor with java.io.Serializable
The constructor/extractor for
PolyType
instances.The constructor/extractor for
PolyType
instances.- Definition Classes
- Types → Types
- object ProperTypeKind
- Definition Classes
- Kinds
- object RefTree extends internal.SymbolTable.RefTreeExtractor
The constructor/extractor for
RefTree
instances.The constructor/extractor for
RefTree
instances.- Definition Classes
- Trees → Trees
- object ReferenceToBoxed extends internal.SymbolTable.ReferenceToBoxedExtractor with java.io.Serializable
- Definition Classes
- Trees
- object RefinedType extends internal.SymbolTable.RefinedTypeExtractor with java.io.Serializable
The constructor/extractor for
RefinedType
instances.The constructor/extractor for
RefinedType
instances.- Definition Classes
- Types → Types
- object Return extends internal.SymbolTable.ReturnExtractor with java.io.Serializable
The constructor/extractor for
Return
instances.The constructor/extractor for
Return
instances.- Definition Classes
- Trees → Trees
- object Scope
- Definition Classes
- Scopes
- object Select extends internal.SymbolTable.SelectExtractor with java.io.Serializable
The constructor/extractor for
Select
instances.The constructor/extractor for
Select
instances.- Definition Classes
- Trees → Trees
- object SelectFromTypeTree extends internal.SymbolTable.SelectFromTypeTreeExtractor with java.io.Serializable
The constructor/extractor for
SelectFromTypeTree
instances.The constructor/extractor for
SelectFromTypeTree
instances.- Definition Classes
- Trees → Trees
- object SingleType extends internal.SymbolTable.SingleTypeExtractor with java.io.Serializable
The constructor/extractor for
SingleType
instances.The constructor/extractor for
SingleType
instances.- Definition Classes
- Types → Types
- object SingletonTypeTree extends internal.SymbolTable.SingletonTypeTreeExtractor with java.io.Serializable
The constructor/extractor for
SingletonTypeTree
instances.The constructor/extractor for
SingletonTypeTree
instances.- Definition Classes
- Trees → Trees
- object Star extends internal.SymbolTable.StarExtractor with java.io.Serializable
The constructor/extractor for
Star
instances.The constructor/extractor for
Star
instances.- Definition Classes
- Trees → Trees
- object StaticallyAnnotatedType
- Definition Classes
- Types
- object Super extends internal.SymbolTable.SuperExtractor with java.io.Serializable
The constructor/extractor for
Super
instances.The constructor/extractor for
Super
instances.- Definition Classes
- Trees → Trees
- object SuperType extends internal.SymbolTable.SuperTypeExtractor with java.io.Serializable
The constructor/extractor for
SuperType
instances.The constructor/extractor for
SuperType
instances.- Definition Classes
- Types → Types
- object SyntheticUnitAttachment extends internal.SymbolTable.PlainAttachment with Product with Serializable
Identifies unit constants which were inserted by the compiler (e.g.
Identifies unit constants which were inserted by the compiler (e.g. gen.mkBlock)
- Definition Classes
- StdAttachments
- object Template extends internal.SymbolTable.TemplateExtractor with java.io.Serializable
The constructor/extractor for
Template
instances.The constructor/extractor for
Template
instances.- Definition Classes
- Trees → Trees
- object TermName extends internal.Names.TermNameExtractor
The constructor/extractor for
TermName
instances.The constructor/extractor for
TermName
instances.- Definition Classes
- Names → Names
- object This extends internal.SymbolTable.ThisExtractor with java.io.Serializable
The constructor/extractor for
This
instances.The constructor/extractor for
This
instances.- Definition Classes
- Trees → Trees
- object ThisType extends internal.SymbolTable.ThisTypeExtractor with java.io.Serializable
The constructor/extractor for
ThisType
instances.The constructor/extractor for
ThisType
instances.- Definition Classes
- Types → Types
- object Throw extends internal.SymbolTable.ThrowExtractor with java.io.Serializable
The constructor/extractor for
Throw
instances.The constructor/extractor for
Throw
instances.- Definition Classes
- Trees → Trees
- object ThrownException
Extracts the type of the thrown exception from an AnnotationInfo.
Extracts the type of the thrown exception from an AnnotationInfo.
Supports both “old-style”
@throws(classOf[Exception])
as well as “new-style”@throws[Exception]("cause")
annotations.- Definition Classes
- AnnotationInfos
- object Try extends internal.SymbolTable.TryExtractor with java.io.Serializable
The constructor/extractor for
Try
instances.The constructor/extractor for
Try
instances.- Definition Classes
- Trees → Trees
- object TypeApply extends internal.SymbolTable.TypeApplyExtractor with java.io.Serializable
The constructor/extractor for
TypeApply
instances.The constructor/extractor for
TypeApply
instances.- Definition Classes
- Trees → Trees
- object TypeBounds extends internal.SymbolTable.TypeBoundsExtractor with java.io.Serializable
The constructor/extractor for
TypeBounds
instances.The constructor/extractor for
TypeBounds
instances.- Definition Classes
- Types → Types
- object TypeBoundsTree extends internal.SymbolTable.TypeBoundsTreeExtractor with java.io.Serializable
The constructor/extractor for
TypeBoundsTree
instances.The constructor/extractor for
TypeBoundsTree
instances.- Definition Classes
- Trees → Trees
- object TypeConKind
- Definition Classes
- Kinds
- object TypeDef extends internal.SymbolTable.TypeDefExtractor with java.io.Serializable
The constructor/extractor for
TypeDef
instances.The constructor/extractor for
TypeDef
instances.- Definition Classes
- Trees → Trees
- object TypeName extends internal.Names.TypeNameExtractor
The constructor/extractor for
TypeName
instances.The constructor/extractor for
TypeName
instances.- Definition Classes
- Names → Names
- object TypeRef extends internal.SymbolTable.TypeRefExtractor with java.io.Serializable
The constructor/extractor for
TypeRef
instances.The constructor/extractor for
TypeRef
instances.- Definition Classes
- Types → Types
- object TypeTree extends internal.SymbolTable.TypeTreeExtractor with java.io.Serializable
The constructor/extractor for
TypeTree
instances.The constructor/extractor for
TypeTree
instances.- Definition Classes
- Trees → Trees
- object TypeVar extends java.io.Serializable
- Definition Classes
- Types
- object Typed extends internal.SymbolTable.TypedExtractor with java.io.Serializable
The constructor/extractor for
Typed
instances.The constructor/extractor for
Typed
instances.- Definition Classes
- Trees → Trees
- object UnApply extends internal.SymbolTable.UnApplyExtractor with java.io.Serializable
The constructor/extractor for
UnApply
instances.The constructor/extractor for
UnApply
instances.- Definition Classes
- Trees → Trees
- object UnmappableAnnotArg extends internal.SymbolTable.ClassfileAnnotArg with Product with Serializable
- Definition Classes
- AnnotationInfos
- object UnmappableAnnotation extends internal.SymbolTable.CompleteAnnotationInfo
- Definition Classes
- AnnotationInfos
- object UnmappableTree extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with Product with Serializable
- Definition Classes
- Types
- object UseInvokeSpecial extends internal.SymbolTable.PlainAttachment with Product with Serializable
- Definition Classes
- StdAttachments
- object ValDef extends internal.SymbolTable.ValDefExtractor with java.io.Serializable
The constructor/extractor for
ValDef
instances.The constructor/extractor for
ValDef
instances.- Definition Classes
- Trees → Trees
- object ValOrDefDef
- Definition Classes
- Trees
- object WildcardType extends internal.SymbolTable.ProtoType with Product with Serializable
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 → Types
- object abstractTypesToBounds extends internal.SymbolTable.TypeMap
Type with all top-level occurrences of abstract types replaced by their bounds
Type with all top-level occurrences of abstract types replaced by their bounds
- Definition Classes
- TypeMaps
- object adaptToNewRunMap extends internal.SymbolTable.TypeMap
- Definition Classes
- TypeMaps
- object binarynme
Java binary names, like scala/runtime/Nothing$.
Java binary names, like scala/runtime/Nothing$.
- Definition Classes
- StdNames
- object definitions extends internal.SymbolTable.DefinitionsClass
A value containing all standard definitions in DefinitionsApi
A value containing all standard definitions in DefinitionsApi
- Definition Classes
- Definitions → StandardDefinitions
- object dropIllegalStarTypes extends internal.SymbolTable.TypeMap
Turn any T* types into Seq[T] except when in method parameter position.
Turn any T* types into Seq[T] except when in method parameter position.
- Definition Classes
- TypeMaps
- object dropSingletonType extends internal.SymbolTable.TypeMap
Remove any occurrence of type <singleton> from this type and its parents
Remove any occurrence of type <singleton> from this type and its parents
- Definition Classes
- TypeMaps
- object fulltpnme extends internal.SymbolTable.TypeNames
For fully qualified type names.
For fully qualified type names.
- Definition Classes
- StdNames
- object inferKind
Starting from a Symbol (sym) or a Type (tpe), infer the kind that classifies it (sym.tpeHK/tpe).
Starting from a Symbol (sym) or a Type (tpe), infer the kind that classifies it (sym.tpeHK/tpe).
- Definition Classes
- Kinds
- object nme extends internal.SymbolTable.TermNames
- Definition Classes
- StdNames
- object noPrint extends (internal.SymbolTable.Tree) => Boolean
There's a whole lot of implementation detail which is nothing but noise when you are trying to see what's going on.
There's a whole lot of implementation detail which is nothing but noise when you are trying to see what's going on. This is my attempt to filter it out.
- Definition Classes
- TypeDebugging
- object noSelfType extends internal.SymbolTable.ValDef with internal.SymbolTable.CannotHaveAttrs
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 → Trees
- object normalizeAliases extends internal.SymbolTable.TypeMap
Normalize any type aliases within this type (@see Type#normalize).
Normalize any type aliases within this type (@see Type#normalize). Note that this depends very much on the call to "normalize", not "dealias", so it is no longer carries the too-stealthy name "deAlias".
- Definition Classes
- TypeMaps
- object pendingSuperCall extends internal.SymbolTable.Apply with internal.SymbolTable.CannotHaveAttrs
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 → Trees
- object perRunCaches
- Definition Classes
- SymbolTable
- object tpnme extends internal.SymbolTable.TypeNames
- Definition Classes
- StdNames
- object traceSymbols extends TraceSymbolActivity
- Definition Classes
- SymbolTable
- object treeInfo extends TreeInfo
- Definition Classes
- JavaUniverse → SymbolTable
- object typeDebug
Light color wrappers.
Light color wrappers.
- Definition Classes
- TypeDebugging
- object typeVarToOriginMap extends internal.SymbolTable.TypeMap
A map to convert each occurrence of a type variable to its origin.
A map to convert each occurrence of a type variable to its origin.
- Definition Classes
- TypeMaps
- object unwrapToClass extends internal.SymbolTable.ClassUnwrapper
- Definition Classes
- Types
- object unwrapToStableClass extends internal.SymbolTable.ClassUnwrapper
- Definition Classes
- Types
- object unwrapWrapperTypes extends internal.SymbolTable.TypeUnwrapper
- Definition Classes
- Types
- object wildcardExtrapolation extends internal.SymbolTable.VariancedTypeMap
Get rid of BoundedWildcardType where variance allows us to do so.
Get rid of BoundedWildcardType where variance allows us to do so. Invariant:
wildcardExtrapolation(tp) =:= tp
For example, the MethodType given by
def bla(x: (_ >: String)): (_ <: Int)
is both a subtype and a supertype ofdef bla(x: String): Int
.- Definition Classes
- TypeMaps
- object wildcardToTypeVarMap extends internal.SymbolTable.TypeMap
A map to convert every occurrence of a wildcard type to a fresh type variable
A map to convert every occurrence of a wildcard type to a fresh type variable
- Definition Classes
- TypeMaps
Deprecated Value Members
- final def assert(assertion: Boolean): Unit
- Definition Classes
- SymbolTable
- Annotations
- @deprecated
- Deprecated
(Since version 2.12.5) consider supplying an explanatory message
- final def atPhase[T](ph: Phase)(op: => T): T
- Definition Classes
- SymbolTable
- Annotations
- @deprecated @inline()
- Deprecated
(Since version 2.10.0) use enteringPhase
- lazy 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 → Internals
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) compatibility with Scala 2.10 EOL
- lazy val emptyValDef: noSelfType.type
- Definition Classes
- Trees → Trees
- Annotations
- @deprecated
- Deprecated
(Since version 2.11.0) use
noSelfType
instead
- def freshExistentialName(suffix: String): TypeName
- Attributes
- protected
- Definition Classes
- Symbols
- Annotations
- @deprecated
- Deprecated
(Since version 2.12.1) Use overload that accepts an id
- def isRaw(sym: Symbol, args: List[Type]): Boolean
- Definition Classes
- Types
- Annotations
- @deprecated
- Deprecated
(Since version 2.10.1) use isRawType
- 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 → Trees
- Annotations
- @deprecated
- Deprecated
(Since version Use Tree#transform instead) 2.12.3
- 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 → Trees
- Annotations
- @deprecated
- Deprecated
(Since version Use Tree#traverse instead) 2.12.3
- final def newAsSeenFromMap(pre: Type, clazz: Symbol): AsSeenFromMap
- Definition Classes
- TypeMaps
- Annotations
- @deprecated
- Deprecated
(Since version 2.12.0) use new AsSeenFromMap instead
- def nextExistentialId(): Int
- Attributes
- protected
- Definition Classes
- SynchronizedSymbols → Symbols
- Annotations
- @deprecated
- Deprecated
(Since version 2.12.1) Global existential IDs no longer used
- def polyType(params: List[Symbol], tpe: Type): Type
- Definition Classes
- Types
- Annotations
- @deprecated
- Deprecated
(Since version 2.10.0) use genPolyType(...) instead
- final def require(requirement: Boolean): Unit
- Definition Classes
- SymbolTable
- Annotations
- @deprecated
- Deprecated
(Since version 2.12.5) consider supplying an explanatory message
- 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
- 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
- Annotations
- @deprecated
- Deprecated
(Since version 2.12.3) Use Tree#traverse instead
- def →[B](y: B): (JavaUniverse, B)
- Implicit
- This member is added by an implicit conversion from JavaUniverse toArrowAssoc[JavaUniverse] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use
->
instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.