JavaUniverse

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

Linear Supertypes

SymbolTable, runtime.ThreadLocalStorage, Gil, SynchronizedOps, SynchronizedTypes, SynchronizedSymbols, SymbolLoaders, JavaMirrors, TwoWayCaches, api.JavaUniverse, ReflectSetup, JavaUniverseForce, internal.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, internal.tpe.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

Ordering

Grouped
Alphabetic
By Inheritance

Inherited

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

Implicitly

by any2stringadd
by StringFormat
by Ensuring
by ArrowAssoc

Hide All
Show All

Visibility

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, and javaArgs the payload of Java annotations.

Definition Classes
Annotations
abstract class ConstantApi extends AnyRef
The API of Constant instances.
The API of Constant instances.

Definition Classes
Constants
abstract class ConstantExtractor extends AnyRef
An extractor class to create and pattern match with syntax Constant(value) where value is the Scala value of the constant.
An extractor class to create and pattern match with syntax Constant(value) where value 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 CompatApi extends AnyRef

Definition Classes
Internals
See also
compat
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( ... )
trait FreeTermSymbolApi extends Universe.TermSymbolApi
The API of free term symbols.
The API of free term symbols. The main source of information about symbols is the Symbols page.
$SYMACCESSORS

Definition Classes
Internals
trait FreeTypeSymbolApi extends Universe.TypeSymbolApi
The API of free type symbols.
The API of free type symbols. The main source of information about symbols is the Symbols page.
$SYMACCESSORS

Definition Classes
Internals
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 macro Universe or a runtime reflection Universe), but sometimes there is a need to migrate artifacts from one Universe 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 Universes, which is reflected by the fact that types of artifacts from different universes are not compatible. By using Importers, however, they be imported from one universe into another. For example, to import foo.bar.Baz from the source Universe to the target Universe, an importer will first check whether the entire owner chain exists in the target Universe. 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 target Universe.
Since importers match Symbol tables of the source and the target Universes using plain string names, it is programmer's responsibility to make sure that imports don't distort semantics, e.g., that foo.bar.Baz in the source Universe means the same that foo.bar.Baz does in the target Universe.
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) provides universe.compat: InternalApi, whereas compile-time API endpoints (instances of scala.reflect.macros.Context) provide c.compat: ContextInternalApi, which extends InternalApi 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 through elem.
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 a Tree.
A type class that defines a representation of T as a Tree.

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 a Tree.
A type class that defines a way to extract instance of T from a Tree.

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 and fq string interpolators that are also known as quasiquotes.
Implicit class that introduces q, tq, cq, pq and fq string interpolators that are also known as quasiquotes. With their help you can easily manipulate Scala reflection ASTs.

Definition Classes
Quasiquotes
See also
http://docs.scala-lang.org/overviews/quasiquotes/intro.html
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 as isPublic or isFinal, params and returnType methods for method symbols, baseClasses for class symbols and so on. Some of these methods don't make sense for certain subclasses of Symbol and return NoSymbol, 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 as isPublic or isFinal, params and returnType methods for method symbols, baseClasses for class symbols and so on. Some of these methods don't make sense for certain subclasses of Symbol and return NoSymbol, 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 as isPublic or isFinal, params and returnType methods for method symbols, baseClasses for class symbols and so on. Some of these methods don't make sense for certain subclasses of Symbol and return NoSymbol, 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 as isPublic or isFinal, params and returnType methods for method symbols, baseClasses for class symbols and so on. Some of these methods don't make sense for certain subclasses of Symbol and return NoSymbol, 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 as isPublic or isFinal, params and returnType methods for method symbols, baseClasses for class symbols and so on. Some of these methods don't make sense for certain subclasses of Symbol and return NoSymbol, 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 as isPublic or isFinal, params and returnType methods for method symbols, baseClasses for class symbols and so on. Some of these methods don't make sense for certain subclasses of Symbol and return NoSymbol, 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 have isType returning true. Otherwise TypeApply 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 AssignOrNamedArgApi extends Universe.TermTreeApi
The API that all assigns support
The API that all assigns support

Definition Classes
Trees
abstract class AssignOrNamedArgExtractor extends AnyRef
An extractor class to create and pattern match with syntax AssignOrNamedArg(lhs, rhs).
An extractor class to create and pattern match with syntax AssignOrNamedArg(lhs, rhs). This AST node corresponds to the following Scala code:
```
m.f(lhs = rhs)
```
```
@annotation(lhs = rhs)
```
Definition Classes
Trees
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 to Literal(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 pat if guard => body
If the guard is not present, the guard is set to EmptyTree. If the body is not specified, the body is set to Literal(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] impl
Where 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 = rhs
If the return type is not specified explicitly (i.e. is meant to be inferred), this is expressed by having tpt set to TypeTree() (but not to an EmptyTree!).

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) thenp else elsep
If the alternative is not present, the elsep is set to Literal(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.{x, y => z, _}
Would be represented as:
Import(qual, List(("x", "x"), ("y", "z"), (WILDCARD, null)))
The symbol of an Import is an import symbol @see Symbol.newImport. It's used primarily as a marker to check that the import has been typechecked.

Definition Classes
Trees
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 the Import 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 like val (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 impl
Where 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 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 T
This 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 expr
The 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 have isTerm returning true. Otherwise SelectFromTypeTree 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 have isType returning true. Otherwise Select 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 block catch { catches } finally finalizer
If the finalizer is not present, the finalizer is set to EmptyTree.

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 have isTerm returning true. Otherwise AppliedTypeTree 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] = rhs
mods type name[tparams] >: lo <: hi
First usage illustrates TypeDefs representing type aliases and type parameters. Second usage illustrates TypeDefs representing abstract types, where lo and hi are both TypeBoundsTrees and Modifier.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 a Type in a Tree.

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 and try 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 = rhs
mods var name: tpt = rhs
mods 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 to TypeTree() (but not to an EmptyTree!).

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
scala.reflect.api.TypeTags
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 of T can be accessed via the tpe field.
If an implicit value of type WeakTypeTag[T] is required, the compiler will create one, and the reflective representation of T can be accessed via the tpe field. Components of T can be references to type parameters or abstract types. Note that WeakTypeTag makes an effort to be as concrete as possible, i.e. if TypeTags 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 expects T to be perhaps be partially abstract, but requires special care to handle this case. However, if T is expected to be fully known, use scala.reflect.api.TypeTags#TypeTag instead, which statically guarantees this property.
For more information about TypeTags, see the Reflection Guide: TypeTags

Definition Classes
TypeTags
Annotations
@implicitNotFound( "No WeakTypeTag available for ${T}" )
See also
scala.reflect.api.TypeTags
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 type underlying. 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) with bounds denoting the type bounds.
An extractor class to create and pattern match with syntax BoundedWildcardTypeExtractor(bounds) with bounds 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, and clazz is the symbol of the class itself.
An extractor class to create and pattern match with syntax ClassInfo(parents, decls, clazz) Here, parents is the list of parent types of the class, decls is the scope containing all declarations in the class, and clazz is the symbol of the class itself.

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 and underlying 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, and restpe 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, and restpe is the result type of the method. If the method is curried, restpe would be another MethodType. Note: MethodType(Nil, Int) would be the type of a method defined with an empty parameter list.
```
def f(): Int
```
If the method is completely parameterless, as in
```
def f: Int
```
its type is a NullaryMethodType.
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 and resultType 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, and decls is the scope containing all declarations in the class.
An extractor class to create and pattern match with syntax RefinedType(parents, decls) Here, parents is the list of parent types of the class, and decls is the scope containing all declarations in the class.

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, and sym is the stable value symbol referred to by the single-type.
An extractor class to create and pattern match with syntax SingleType(pre, sym) Here, pre is the prefix of the single-type, and sym is the stable value symbol referred to by the single-type.

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 SingleType(thistpe, supertpe)
An extractor class to create and pattern match with syntax SingleType(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) where sym is the class prefix of the this type.
An extractor class to create and pattern match with syntax ThisType(sym) where sym is the class prefix of the this type.

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 the TypeBounds pair, and upper is the upper bound.
An extractor class to create and pattern match with syntax TypeBound(lower, upper) Here, lower is the lower bound of the TypeBounds pair, and upper is the upper bound.

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, and args 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, and args is a possible empty list of type arguments.

Definition Classes
Types
trait MacroCompatApi extends CompatApi

Definition Classes
Universe
See also
compat
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 to ClassfileAnnotation (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 form StaticAnnotation.
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: zipped params/args nonEmpty.
Precondition: zipped params/args nonEmpty. (Size equivalence 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 internal.SymbolTable.ArrayArgumentApi with Product with Serializable
Represents an array of classfile annotation arguments
Represents an array of classfile annotation arguments

Definition Classes
AnnotationInfos
type ArrayArgument = ArrayAnnotArg
The constructor/extractor for ArrayArgument instances.
The constructor/extractor for ArrayArgument instances.

Definition Classes
AnnotationInfos → Annotations
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
case class AssignOrNamedArg extends internal.SymbolTable.Tree with internal.SymbolTable.TermTree with internal.SymbolTable.AssignOrNamedArgApi 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.Type 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:
1. 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.Traverser

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 classfile annotations (which are written to bytecode as java annotations) are either:
Arguments to classfile annotations (which are written to bytecode as java annotations) are either:
- constants
- arrays of constants
- or nested classfile annotations
Definition Classes
AnnotationInfos
class CodePrinter extends internal.SymbolTable.TreePrinter

Definition Classes
Printers
class CollectTreeTraverser[T] extends internal.SymbolTable.Traverser

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.TypeTraverserWithResult[internal.SymbolTable.Symbol]

Attributes
protected
Definition Classes
CommonOwners
type Compat = MacroCompatApi

Definition Classes
Internals → Internals
See also
compat
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 use CompoundTypeTree.tpe. Therefore we need this hack (see Reshape.toPreTyperTypeTree for a detailed explanation).

Definition Classes
StdAttachments
case class Constant extends internal.SymbolTable.ConstantApi with Product with Serializable

Definition Classes
Constants
abstract case class ConstantType extends internal.SymbolTable.SingletonType with internal.SymbolTable.ConstantTypeApi with Product with Serializable
A class representing a constant type.
A class representing a constant type.

Definition Classes
Types
class ContainsCollector extends internal.SymbolTable.TypeCollector[Boolean]
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.Traverser 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 contain ErasedValueType-s. In order to correctly consider the overriding and overridden signatures as equivalent in run/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.TypeMap
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
class FilterTreeTraverser extends internal.SymbolTable.Traverser

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

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
class ForEachTypeTraverser extends internal.SymbolTable.TypeTraverser

Definition Classes
TypeMaps
class ForeachPartialTreeTraverser extends internal.SymbolTable.Traverser

Definition Classes
Trees
class ForeachTreeTraverser extends internal.SymbolTable.Traverser

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.nonEmpty.
Precondition: params.nonEmpty. (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
InternalApi
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 JavaMethodType extends internal.SymbolTable.MethodType

Definition Classes
Types
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 internal.SymbolTable.LiteralArgumentApi 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
type LiteralArgument = LiteralAnnotArg
The constructor/extractor for LiteralArgument instances.
The constructor/extractor for LiteralArgument instances.

Definition Classes
AnnotationInfos → Annotations
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 encloses pos.

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 Throwable with ControlThrowable

Definition Classes
Types
class MissingTypeControl extends Throwable with 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 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 internal.SymbolTable.NestedArgumentApi with Product with Serializable
Represents a nested classfile annotation
Represents a nested classfile annotation

Definition Classes
AnnotationInfos
type NestedArgument = NestedAnnotArg
The constructor/extractor for NestedArgument instances.
The constructor/extractor for NestedArgument instances.

Definition Classes
AnnotationInfos → Annotations
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 Throwable with 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
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.Traverser

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
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 use refinedType 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 use refinedType 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
case class ScalaSigBytes extends internal.SymbolTable.ClassfileAnnotArg with Product with Serializable
A specific annotation argument that encodes an array of bytes as an array of Long.
A specific annotation argument that encodes an array of bytes as an array of Long. The type of the argument declared in the annotation must be String. This specialised class is used to encode Scala signatures for reasons of efficiency, both in term of class-file size and in term of compiler performance. Details about the storage format of pickles at the bytecode level (classfile annotations) can be found in SIP-10.

Definition Classes
AnnotationInfos
class Scope extends 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 use singleType 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.Transformer
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.Transformer
A transformer that replaces tree from with tree to in a given tree
A transformer that replaces tree from with tree to in a given tree

Definition Classes
Trees
trait TreeStackTraverser extends internal.SymbolTable.Traverser

Definition Classes
Trees
class TreeSubstituter extends internal.SymbolTable.Transformer

Definition Classes
Trees
class TreeSymSubstTraverser extends internal.SymbolTable.TypeMapTreeSubstituter

Definition Classes
Trees
class TreeSymSubstituter extends internal.SymbolTable.Transformer
Substitute symbols in from with symbols in to.
Substitute symbols in from with symbols in to. 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 an info that refer a symbol in from 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.TypeTraverser

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

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 use typeRef for creation.
A class for named types of the form <prefix>.<sym.name>[args] Cannot be created directly; one should always use typeRef 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
abstract class TypeTraverserWithResult[T] extends internal.SymbolTable.TypeTraverser

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
trait UnderConstructionTransformer extends internal.SymbolTable.Transformer
Tracks the classes currently under construction during a transform
Tracks the classes currently under construction during a transform

Definition Classes
Trees
class UndoLog extends Clearable

Definition Classes
TypeConstraints
final class UniqueConstantType extends internal.SymbolTable.ConstantType

Definition Classes
Types
final class UniqueErasedValueType extends internal.SymbolTable.ErasedValueType

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.Traverser
Used in Refchecks.
Used in Refchecks. TODO - eliminate duplication with varianceInType

Definition Classes
Variances
trait ArrayArgumentApi extends AnyRef
API of ArrayArgument instances.
API of ArrayArgument instances. The main source of information about annotations is the scala.reflect.api.Annotations page.

Definition Classes
Annotations
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use Annotation.tree to inspect annotation arguments
abstract class ArrayArgumentExtractor extends AnyRef
An extractor class to create and pattern match with syntax ArrayArgument(args) where args is the argument array.
An extractor class to create and pattern match with syntax ArrayArgument(args) where args is the argument array.

Definition Classes
Annotations
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use Annotation.tree to inspect annotation arguments
trait JavaArgumentApi extends AnyRef
Has no special methods.
Has no special methods. Is here to provides erased identity for CompoundType.

Definition Classes
Annotations
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use Annotation.tree to inspect annotation arguments
trait LiteralArgumentApi extends AnyRef
The API of LiteralArgument instances.
The API of LiteralArgument instances. The main source of information about annotations is the scala.reflect.api.Annotations page.

Definition Classes
Annotations
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use Annotation.tree to inspect annotation arguments
abstract class LiteralArgumentExtractor extends AnyRef
An extractor class to create and pattern match with syntax LiteralArgument(value) where value is the constant argument.
An extractor class to create and pattern match with syntax LiteralArgument(value) where value is the constant argument.

Definition Classes
Annotations
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use Annotation.tree to inspect annotation arguments
trait NestedArgumentApi extends AnyRef
API of NestedArgument instances.
API of NestedArgument instances. The main source of information about annotations is the scala.reflect.api.Annotations page.

Definition Classes
Annotations
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use Annotation.tree to inspect annotation arguments
abstract class NestedArgumentExtractor extends AnyRef
An extractor class to create and pattern match with syntax NestedArgument(annotation) where annotation is the nested annotation.
An extractor class to create and pattern match with syntax NestedArgument(annotation) where annotation is the nested annotation.

Definition Classes
Annotations
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use Annotation.tree to inspect annotation arguments
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
scala.reflect.macros.Enclosures
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
scala.reflect.macros.Enclosures
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
scala.reflect.macros.Enclosures
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
scala.reflect.macros.Enclosures
type BuildApi = ReificationSupportApi

Definition Classes
Internals
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use internal.ReificationSupportApi instead
type ModifiersCreator = ModifiersExtractor

Definition Classes
Trees
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use ModifiersExtractor instead

Value Members

object Expr extends Serializable
Constructor/Extractor for Expr.
Constructor/Extractor for Expr.
Can be useful, when having a tree and wanting to splice it in reify call, in which case the tree first needs to be wrapped in an expr.
The main source of information about exprs is the scala.reflect.api.Exprs page.

Definition Classes
Exprs
object Liftable extends Universe.StandardLiftableInstances
Companion to Liftable type class that contains standard instances and provides a helper apply method to simplify creation of new ones.
Companion to Liftable type class that contains standard instances and provides a helper apply 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 helper apply method to simplify creation of new ones.
Companion to Unliftable type class that contains standard instances and provides a helper apply method to simplify creation of new ones.

Definition Classes
Liftables
object BooleanFlag extends Serializable

Definition Classes
Printers
object TypeTag extends Serializable
Type tags corresponding to primitive types and constructor/extractor for WeakTypeTags.
Type tags corresponding to primitive types and constructor/extractor for WeakTypeTags.

Definition Classes
TypeTags
object WeakTypeTag extends Serializable
Type tags corresponding to primitive types and constructor/extractor for WeakTypeTags.
Type tags corresponding to primitive types and constructor/extractor for WeakTypeTags.

Definition Classes
TypeTags
final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def +(other: String): String

Implicit
This member is added by an implicit conversion from JavaUniverse to any2stringadd[JavaUniverse] performed by method any2stringadd in scala.Predef.
Definition Classes
any2stringadd
def ->[B](y: B): (JavaUniverse, B)

Implicit
This member is added by an implicit conversion from JavaUniverse to ArrowAssoc[JavaUniverse] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
Annotations
@inline()
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
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
val ArrayArgument: ArrayAnnotArg.type
The constructor/extractor for ArrayArgument instances.
The constructor/extractor for ArrayArgument instances.

Definition Classes
AnnotationInfos → Annotations
implicit val ArrayArgumentTag: ClassTag[ArrayAnnotArg]

Definition Classes
AnnotationInfos
implicit val AssignOrNamedArgTag: ClassTag[AssignOrNamedArg]

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
def JavaMethodType(params: List[Symbol], resultType: Type): JavaMethodType
The canonical creator for implicit method types
The canonical creator for implicit method types

Definition Classes
Types
implicit val LabelDefTag: ClassTag[LabelDef]

Definition Classes
Trees
val LiteralArgument: LiteralAnnotArg.type
The constructor/extractor for LiteralArgument instances.
The constructor/extractor for LiteralArgument instances.

Definition Classes
AnnotationInfos → Annotations
implicit val LiteralArgumentTag: ClassTag[LiteralAnnotArg]

Definition Classes
AnnotationInfos
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
val NestedArgument: NestedAnnotArg.type
The constructor/extractor for NestedArgument instances.
The constructor/extractor for NestedArgument instances.

Definition Classes
AnnotationInfos → Annotations
implicit val NestedArgumentTag: ClassTag[NestedAnnotArg]

Definition Classes
AnnotationInfos
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) A New(t, as) is expanded to: (new t).<init>(as)
Factory method for object creation new tpt(args_1)...(args_n) A New(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.
A factory method for Select nodes. The string name argument is assumed to represent a TermName.

Definition Classes
Trees → Trees
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 the super.
Creates a tree that selects a specific member sym without having to qualify the super. For example, given traits B <:< A, a class C <:< B needs to invoke A.$init$. If A is not a direct parent, a tree super[A].$init$ would not type check ("does not name a parent"). So we generate super.$init$ and pre-assign the correct symbol. A special-case in typedSelectInternal assigns the correct type A to the super 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 scope tp.decls where thistp is the narrowed owner type of the scope.
Make symbol sym a member of scope tp.decls where thistp 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
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
appliedType
def appliedType(tycon: Type, args: Type*): Type

Definition Classes
Types → Types
See also
appliedType
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): Unit

Definition Classes
SymbolTable
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
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 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
@native() @throws( ... )
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
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()
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
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 of the same class as tp, i.e.
Create a new MethodType of the same class as tp, i.e. keep JavaMethodType

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 and as across the given function.
Derives a new list of symbols from the given list by mapping the given list of syms and as 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 otherwise
dev-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, start: 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 in tree 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 to Ensuring[JavaUniverse] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: (JavaUniverse) ⇒ Boolean): JavaUniverse

Implicit
This member is added by an implicit conversion from JavaUniverse to Ensuring[JavaUniverse] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean, msg: ⇒ Any): JavaUniverse

Implicit
This member is added by an implicit conversion from JavaUniverse to Ensuring[JavaUniverse] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean): JavaUniverse

Implicit
This member is added by an implicit conversion from JavaUniverse to Ensuring[JavaUniverse] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
final def 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: Any): Boolean

Definition Classes
AnyRef → Any
def erasure: Erasure { val global: JavaUniverse.this.type }

Definition Classes
Transforms
def erasurePhase: SomePhase.type

Definition Classes
JavaUniverse → SymbolTable
def existentialAbstraction(tparams: List[Symbol], tpe0: Type): Type
A creator for existential types.
A creator for existential types. This generates:
tpe1 where { tparams }
where tpe1 is the result of extrapolating tpe with respect to tparams. Extrapolating means that type variables in tparams occurring in covariant positions are replaced by upper bounds, (minus any SingletonClass markers), type variables in tparams 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 in tparams.
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 type tpe.

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 type tp, 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 type tp, produce a set of fresh type parameters and a type so that it can be abstracted to an existential type. Every type symbol T in rawSyms is mapped to a clone. Every term symbol x of type T in rawSyms 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 arguments tp1, arg2 and print trace of computation.
Perform operation p on arguments tp1, 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 for op(found, required).
If option explaintypes is set, print a subtype trace for op(found, required).

Definition Classes
Types
def explainTypes(found: Type, required: Type): Unit
If option explaintypes is set, print a subtype trace for found <:< required.
If option explaintypes is set, print a subtype trace for found <:< 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: TraversableOnce[A])(p: (A) ⇒ Boolean)(orElse: ⇒ A): A

Definition Classes
Collections
final def findPhaseWithName(phaseName: String): Phase

Definition Classes
SymbolTable
def findRecursiveBounds(ts: List[Type]): List[(Symbol, Symbol)]
From a list of types, find any which take type parameters where the type parameter bounds contain references to other any types in the list (including itself.)
From a list of types, find any which take type parameters where the type parameter bounds contain references to other any types in the list (including itself.)
returns
List of symbol pairs holding the recursive type parameter and the parameter which references it.

Definition Classes
GlbLubs
final def findSymbol(xs: TraversableOnce[Symbol])(p: (Symbol) ⇒ Boolean): Symbol

Definition Classes
SymbolTable
Annotations
@inline()
final def flatCollect[A, B](elems: List[A])(pf: PartialFunction[A, Traversable[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 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
final def foreachWithIndex[A, B](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 to StringFormat[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[_]

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 to elimSuper.
The greatest lower bound of a list of types (as determined by <:<), which have been normalized with regard to elimSuper.

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( ... , "2.11.2" )
def globalError(msg: String): Unit

Definition Classes
Reporting
Annotations
@deprecatedOverriding( ... , "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( ... , "2.11.2" )
def inform(msg: String): Unit

Definition Classes
Reporting
Annotations
@deprecatedOverriding( ... , "2.11.2" )
def informProgress(msg: String): Unit

Definition Classes
SymbolTable
def informTime(msg: String, start: Long): Unit

Definition Classes
SymbolTable
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
InternalApi
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
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
def isErrorOrWildcard(tp: Type): Boolean

Definition Classes
Types
def isExistentialType(tp: Type): Boolean

Definition Classes
Types
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 be tp unchanged if pre is trivial and clazz 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 be tp unchanged if pre is trivial and clazz 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 isReferenceToPredef(t: Tree): Boolean
Is the tree Predef, scala.Predef, or _root_.scala.Predef?
Is the tree Predef, scala.Predef, or _root_.scala.Predef?

Definition Classes
Trees
def isReferenceToScalaMember(t: Tree, Id: Name): Boolean

Definition Classes
Trees
def isSameType(tp1: Type, tp2: Type): Boolean
Do tp1 and tp2 denote equivalent types?
Do tp1 and tp2 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 and tps2 lists of pairwise equivalent types?
Are tps1 and tps2 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 ConstantTypes.
This appears to be equivalent to tp.isInstanceof[SingletonType], except it excludes ConstantTypes.

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 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 parameters tparams?
Do type arguments targs conform to formal parameters tparams?

Definition Classes
Types
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
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
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 symbols tsParams 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 symbols tsParams 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 function f maps all elements to themselves.
like map2, but returns list xs itself - instead of a copy - if function f 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 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 empty
A 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
def markAllCompleted(syms: Symbol*): Unit

Definition Classes
Symbols
def markFlagsCompleted(syms: Symbol*)(mask: Long): Unit

Definition Classes
Symbols
final def matchesType(tp1: Type, tp2: Type, alwaysMatchSimple: Boolean): Boolean
A function implementing tp1 matches tp2.
A function implementing tp1 matches tp2.

Definition Classes
Types
def matchingParams(syms1: List[Symbol], syms2: List[Symbol], syms1isJava: Boolean, syms2isJava: Boolean): Boolean
Are syms1 and syms2 parameter lists with pairwise equivalent types?
Are syms1 and syms2 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 (if variance == Contravariant) of given list of types tps.
Compute lub (if variance == Covariant) or glb (if variance == Contravariant) of given list of types tps. All types in tps are typerefs or singletypes with the same symbol. Return x if the computation succeeds with result x. Return NoType 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: Traversable[Traversable[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) and name 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. If owner is the scala package and name 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 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.

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
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
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( ... , "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( ... , "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
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
def normalizePlus(tp: Type): Type

Definition Classes
Types
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 objToAny(tp: Type): Type

Definition Classes
Types
def openPackageModule(pkgClass: Symbol): Unit
if there's a package member object in pkgClass, enter its members into it.
if there's a package member object in pkgClass, 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 type tp.
Compute an existential type from hidden symbols hidden and type tp.
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
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.type

Definition Classes
JavaUniverse → SymbolTable
def picklerSubTag(tree: Tree): Int

Definition Classes
Translations
def picklerTag(tpe: Type): Int

Definition Classes
Translations
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
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): Unit

Definition Classes
SymbolTable
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 Mirrorss, 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], variances: List[Variance], 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
variances
The variances of type parameters; 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 of tpLo have a stronger type than member symHi of tpHi?
Does member symLo of tpLo have a stronger type than member symHi of tpHi?

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
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 _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
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
def typeFunAnon(tps: List[Symbol], body: Type): Type
A creator for anonymous type functions, where the symbol for the type function still needs to be created.
A creator for anonymous type functions, where the symbol for the type function still needs to be created.
TODO: type params of anonymous type functions, which currently can only arise from normalising type aliases, are owned by the type alias of which they are the eta-expansion higher-order subtyping expects eta-expansion of type constructors that arise from a class; here, the type params are owned by that class, but is that the right thing to do?

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
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
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 arguments
Adds 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
def varianceInType(tp: Type)(tparam: Symbol): Variance
Compute variance of type parameter tparam in type tp.
Compute variance of type parameter tparam in type tp.

Definition Classes
Variances
def varianceInTypes(tps: List[Type])(tparam: Symbol): Variance
Compute variance of type parameter tparam in all types tps.
Compute variance of type parameter tparam in all types tps.

Definition Classes
Variances
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@native() @throws( ... )
def warning(pos: Position, msg: String): Unit

Definition Classes
Reporting
Annotations
@deprecatedOverriding( ... , "2.11.2" )
def warning(msg: String): Unit

Definition Classes
Reporting
Annotations
@deprecatedOverriding( ... , "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
def xtraverse(traverser: Traverser, tree: Tree): Unit
Provides an extension hook for the traversal strategy.
Provides an extension hook for the traversal strategy. Future-proofs against new node types.

Attributes
protected
Definition Classes
Trees
def →[B](y: B): (JavaUniverse, B)

Implicit
This member is added by an implicit conversion from JavaUniverse to ArrowAssoc[JavaUniverse] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
object Alternative extends internal.SymbolTable.AlternativeExtractor with Serializable
The constructor/extractor for Alternative instances.
The constructor/extractor for Alternative instances.

Definition Classes
Trees → Trees
object Annotated extends internal.SymbolTable.AnnotatedExtractor with Serializable
The constructor/extractor for Annotated instances.
The constructor/extractor for Annotated instances.

Definition Classes
Trees → Trees
object AnnotatedType extends internal.SymbolTable.AnnotatedTypeExtractor with 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 Serializable
The constructor/extractor for AppliedTypeTree instances.
The constructor/extractor for AppliedTypeTree instances.

Definition Classes
Trees → Trees
object Apply extends internal.SymbolTable.ApplyExtractor with 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 ArrayAnnotArg extends internal.SymbolTable.ArrayArgumentExtractor with Serializable

Definition Classes
AnnotationInfos
object ArrayTypeRef

Definition Classes
Types
object Assign extends internal.SymbolTable.AssignExtractor with Serializable
The constructor/extractor for Assign instances.
The constructor/extractor for Assign instances.

Definition Classes
Trees → Trees
object AssignOrNamedArg extends internal.SymbolTable.AssignOrNamedArgExtractor with Serializable
The constructor/extractor for AssignOrNamedArg instances.
The constructor/extractor for AssignOrNamedArg 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 Serializable
The constructor/extractor for Bind instances.
The constructor/extractor for Bind instances.

Definition Classes
Trees → Trees
object Block extends internal.SymbolTable.BlockExtractor with Serializable
The constructor/extractor for Block instances.
The constructor/extractor for Block instances.

Definition Classes
Trees → Trees
object BoundedWildcardType extends internal.SymbolTable.BoundedWildcardTypeExtractor with Serializable
The constructor/extractor for BoundedWildcardType instances.
The constructor/extractor for BoundedWildcardType instances.

Definition Classes
Types → Types
object CaseDef extends internal.SymbolTable.CaseDefExtractor with Serializable
The constructor/extractor for CaseDef instances.
The constructor/extractor for CaseDef instances.

Definition Classes
Trees → Trees
object ClassDef extends internal.SymbolTable.ClassDefExtractor with Serializable
The constructor/extractor for ClassDef instances.
The constructor/extractor for ClassDef instances.

Definition Classes
Trees → Trees
object ClassInfoType extends internal.SymbolTable.ClassInfoTypeExtractor with 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 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 Serializable
The constructor/extractor for Constant instances.
The constructor/extractor for Constant instances.

Definition Classes
Constants → Constants
object ConstantType extends internal.SymbolTable.ConstantTypeExtractor with Serializable
The constructor/extractor for ConstantType instances.
The constructor/extractor for ConstantType instances.

Definition Classes
Types → Types
object DefDef extends internal.SymbolTable.DefDefExtractor with 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 Serializable

Definition Classes
Types
object ErroneousCollector extends internal.SymbolTable.TypeCollector[Boolean]
A map to implement the contains method.
A map to implement the contains method.

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 Serializable
The constructor/extractor for ExistentialType instances.
The constructor/extractor for ExistentialType instances.

Definition Classes
Types → Types
object ExistentialTypeTree extends internal.SymbolTable.ExistentialTypeTreeExtractor with 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 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 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) until we start tracking explicit kinds equivalent to typeFun (except that the latter requires tparams nonEmpty).
PP to AM: I've co-opted this for where I know tparams may well be empty, and expecting to get back tpe in such cases. Re being "forgiving" below, can we instead say this is the canonical creator for polyTypes which may or may not be poly? (It filched the standard "canonical creator" name.)

Definition Classes
Types
object HasTypeMember

Definition Classes
Types
object Ident extends internal.SymbolTable.IdentExtractor with Serializable
The constructor/extractor for Ident instances.
The constructor/extractor for Ident instances.

Definition Classes
Trees → Trees
object If extends internal.SymbolTable.IfExtractor with Serializable
The constructor/extractor for If instances.
The constructor/extractor for If instances.

Definition Classes
Trees → Trees
object Import extends internal.SymbolTable.ImportExtractor with Serializable
The constructor/extractor for Import instances.
The constructor/extractor for Import instances.

Definition Classes
Trees → Trees
object ImportSelector extends internal.SymbolTable.ImportSelectorExtractor with 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 Serializable
The constructor/extractor for LabelDef instances.
The constructor/extractor for LabelDef instances.

Definition Classes
Trees → Trees
object Literal extends internal.SymbolTable.LiteralExtractor with Serializable
The constructor/extractor for Literal instances.
The constructor/extractor for Literal instances.

Definition Classes
Trees → Trees
object LiteralAnnotArg extends internal.SymbolTable.LiteralArgumentExtractor with Serializable

Definition Classes
AnnotationInfos
object LookupNotFound extends internal.SymbolTable.NameLookup with Product with Serializable

Definition Classes
Scopes
object Match extends internal.SymbolTable.MatchExtractor with Serializable
The constructor/extractor for Match instances.
The constructor/extractor for Match instances.

Definition Classes
Trees → Trees
object MethodType extends internal.SymbolTable.MethodTypeExtractor with 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 Serializable
The constructor/extractor for Modifiers instances.
The constructor/extractor for Modifiers instances.

Definition Classes
Trees → Trees
object ModuleDef extends internal.SymbolTable.ModuleDefExtractor with Serializable
The constructor/extractor for ModuleDef instances.
The constructor/extractor for ModuleDef instances.

Definition Classes
Trees → Trees
object NestedAnnotArg extends internal.SymbolTable.NestedArgumentExtractor with Serializable

Definition Classes
AnnotationInfos
object New extends internal.SymbolTable.NewExtractor with 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 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 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 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 Serializable

Definition Classes
Trees
object RefinedType extends internal.SymbolTable.RefinedTypeExtractor with Serializable
The constructor/extractor for RefinedType instances.
The constructor/extractor for RefinedType instances.

Definition Classes
Types → Types
object Return extends internal.SymbolTable.ReturnExtractor with 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 Serializable
The constructor/extractor for Select instances.
The constructor/extractor for Select instances.

Definition Classes
Trees → Trees
object SelectFromTypeTree extends internal.SymbolTable.SelectFromTypeTreeExtractor with Serializable
The constructor/extractor for SelectFromTypeTree instances.
The constructor/extractor for SelectFromTypeTree instances.

Definition Classes
Trees → Trees
object SingleType extends internal.SymbolTable.SingleTypeExtractor with Serializable
The constructor/extractor for SingleType instances.
The constructor/extractor for SingleType instances.

Definition Classes
Types → Types
object SingletonTypeTree extends internal.SymbolTable.SingletonTypeTreeExtractor with Serializable
The constructor/extractor for SingletonTypeTree instances.
The constructor/extractor for SingletonTypeTree instances.

Definition Classes
Trees → Trees
object Star extends internal.SymbolTable.StarExtractor with 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 Serializable
The constructor/extractor for Super instances.
The constructor/extractor for Super instances.

Definition Classes
Trees → Trees
object SuperType extends internal.SymbolTable.SuperTypeExtractor with 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 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 Serializable
The constructor/extractor for This instances.
The constructor/extractor for This instances.

Definition Classes
Trees → Trees
object ThisType extends internal.SymbolTable.ThisTypeExtractor with Serializable
The constructor/extractor for ThisType instances.
The constructor/extractor for ThisType instances.

Definition Classes
Types → Types
object Throw extends internal.SymbolTable.ThrowExtractor with 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 Serializable
The constructor/extractor for Try instances.
The constructor/extractor for Try instances.

Definition Classes
Trees → Trees
object TypeApply extends internal.SymbolTable.TypeApplyExtractor with Serializable
The constructor/extractor for TypeApply instances.
The constructor/extractor for TypeApply instances.

Definition Classes
Trees → Trees
object TypeBounds extends internal.SymbolTable.TypeBoundsExtractor with Serializable
The constructor/extractor for TypeBounds instances.
The constructor/extractor for TypeBounds instances.

Definition Classes
Types → Types
object TypeBoundsTree extends internal.SymbolTable.TypeBoundsTreeExtractor with 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 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 Serializable
The constructor/extractor for TypeRef instances.
The constructor/extractor for TypeRef instances.

Definition Classes
Types → Types
object TypeTree extends internal.SymbolTable.TypeTreeExtractor with Serializable
The constructor/extractor for TypeTree instances.
The constructor/extractor for TypeTree instances.

Definition Classes
Trees → Trees
object TypeVar extends Serializable

Definition Classes
Types
object Typed extends internal.SymbolTable.TypedExtractor with Serializable
The constructor/extractor for Typed instances.
The constructor/extractor for Typed instances.

Definition Classes
Trees → Trees
object UnApply extends internal.SymbolTable.UnApplyExtractor with 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 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.Type 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 baseClassesCycleMonitor

Definition Classes
Types
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.TypeMap
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 of def 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 atPhase[T](ph: Phase)(op: ⇒ T): T

Definition Classes
SymbolTable
Annotations
@deprecated @inline()
Deprecated
(Since version 2.10.0) use enteringPhase
def debugwarn(msg: ⇒ String): Unit

Definition Classes
SymbolTable
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use devWarning if this is really a warning; otherwise use log
lazy val emptyValDef: noSelfType.type

Definition Classes
Trees → Trees
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use noSelfType instead
def forInteractive: Boolean

Definition Classes
SymbolTable
Annotations
@deprecated
Deprecated
(Since version 2.11.0) Interactive is implemented with a custom Global; this flag is ignored
def forScaladoc: Boolean

Definition Classes
SymbolTable
Annotations
@deprecated
Deprecated
(Since version 2.11.0) Scaladoc is implemented with a custom Global; this flag is ignored
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
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
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 to TermName("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 to TypeName("List").

Definition Classes
Names
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use explicit TypeName(s) instead

Inherited from SymbolTable

Inherited from runtime.ThreadLocalStorage

Inherited from Gil

Inherited from SynchronizedOps

Inherited from SynchronizedTypes

Inherited from SynchronizedSymbols

Inherited from SymbolLoaders

Inherited from JavaMirrors

Inherited from TwoWayCaches

Inherited from api.JavaUniverse

Inherited from ReflectSetup

Inherited from JavaUniverseForce

Inherited from internal.SymbolTable

Inherited from Reporting

Inherited from Internals

Inherited from FreshNames

Inherited from Translations

Inherited from PrivateWithin

Inherited from ReificationSupport

Inherited from StdCreators

Inherited from StdAttachments

Inherited from CapturedVariables

Inherited from Importers

Inherited from TypeDebugging

Packages

JavaUniverse 

class JavaUniverse extends internal.SymbolTable with JavaUniverseForce with ReflectSetup with SymbolTable

Instance Constructors

Type Members

Example

Value Members

Deprecated Value Members

Inherited from SymbolTable

Inherited from runtime.ThreadLocalStorage

Inherited from Gil

Inherited from SynchronizedOps

Inherited from SynchronizedTypes

Inherited from SynchronizedSymbols

Inherited from SymbolLoaders

Inherited from JavaMirrors

Inherited from TwoWayCaches

Inherited from api.JavaUniverse

Inherited from ReflectSetup

Inherited from JavaUniverseForce

Inherited from internal.SymbolTable

Inherited from Reporting

Inherited from Internals

Inherited from FreshNames

Inherited from Translations

Inherited from PrivateWithin

Inherited from ReificationSupport

Inherited from StdCreators

Inherited from StdAttachments

Inherited from CapturedVariables

Inherited from Importers

Inherited from TypeDebugging

Inherited from Positions

Inherited from Printers

Inherited from Trees

Inherited from AnnotationCheckers

Inherited from AnnotationInfos

Inherited from StdNames

Inherited from Transforms

Inherited from InfoTransformers

Inherited from BaseTypeSeqs

Inherited from Constants

Inherited from Definitions

Inherited from Mirrors

Inherited from Scopes

Inherited from FlagSets

Inherited from ExistentialsAndSkolems

Inherited from Kinds

Inherited from Variances

Inherited from Types

Inherited from internal.tpe.FindMembers

Inherited from TypeConstraints

Inherited from TypeMaps

Inherited from GlbLubs

Inherited from CommonOwners

Inherited from TypeToStrings

Inherited from TypeComparers

Inherited from Symbols

Inherited from Names

Inherited from Collections

Inherited from Universe

Inherited from Universe

Inherited from Internals

Inherited from Quasiquotes

Inherited from Liftables

Inherited from Printers

Inherited from Mirrors

Inherited from StandardLiftables

Inherited from StandardNames

Inherited from StandardDefinitions

Inherited from ImplicitTags

Inherited from TypeTags

Inherited from Exprs

Inherited from Positions

Inherited from Annotations

Inherited from Constants

Inherited from Trees

Inherited from Names

Inherited from Scopes

Inherited from FlagSets

JavaUniverse