Universe

abstract class Universe extends Symbols with Types with FlagSets with Scopes with Names with Trees with Constants with Annotations with Positions with Exprs with TypeTags with ImplicitTags with StandardDefinitions with StandardNames with StandardLiftables with Mirrors with Printers with Liftables with Quasiquotes with Internals

EXPERIMENTAL

Universe provides a complete set of reflection operations which make it possible for one to reflectively inspect Scala type relations, such as membership or subtyping.

scala.reflect.api.Universe has two specialized sub-universes for different scenarios. scala.reflect.api.JavaUniverse adds operations that link symbols and types to the underlying classes and runtime values of a JVM instance-- this can be thought of as the Universe that should be used for all typical use-cases of Scala reflection. scala.reflect.macros.Universe adds operations which allow macros to access selected compiler data structures and operations-- this type of Universe should only ever exist within the implementation of a Scala macro.

Universe can be thought of as the entry point to Scala reflection. It mixes-in, and thus provides an interface to the following main types:

Types represent types
Symbols represent definitions
Trees represent abstract syntax trees
Names represent term and type names
Annotations represent annotations
Positions represent source positions of tree nodes
FlagSet represent sets of flags that apply to symbols and definition trees
Constants represent compile-time constants.

To obtain a Universe to use with Scala runtime reflection, simply make sure to use or import scala.reflect.runtime.universe._

scala> import scala.reflect.runtime.universe._
import scala.reflect.runtime.universe._

scala> typeOf[List[Int]]
res0: reflect.runtime.universe.Type = scala.List[Int]

scala> typeOf[Either[String, Int]]
res1: reflect.runtime.universe.Type = scala.Either[String,Int]

To obtain a Universe for use within a Scala macro, use scala.reflect.macros.blackbox.Context#universe. or scala.reflect.macros.whitebox.Context#universe. For example:

def printf(format: String, params: Any*): Unit = macro impl
def impl(c: Context)(format: c.Expr[String], params: c.Expr[Any]*): c.Expr[Unit] = {
  import c.universe._
  ...
}

For more information about Universes, see the Reflection Guide: Universes

Source: Universe.scala

Linear Supertypes

Internals, Quasiquotes, Liftables, Printers, Mirrors, StandardLiftables, StandardNames, StandardDefinitions, ImplicitTags, TypeTags, Exprs, Positions, Annotations, Constants, Trees, Names, Scopes, FlagSets, Types, Symbols, AnyRef, Any

Known Subclasses

JavaUniverse, Universe

Ordering

Grouped
Alphabetic
By Inheritance

Inherited

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 Universe()

Type Members

abstract type Annotation >: Null <: Universe.AnnotationApi
Information about an annotation.
Information about an annotation.

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

Definition Classes
Annotations
abstract class AnnotationExtractor extends AnyRef
An extractor class to create and pattern match with syntax Annotation(tpe, scalaArgs, javaArgs).
An extractor class to create and pattern match with syntax Annotation(tpe, scalaArgs, javaArgs). Here, tpe is the annotation type, scalaArgs the payload of Scala annotations, and javaArgs the payload of Java annotations.

Definition Classes
Annotations

abstract type Constant >: Null <: Universe.ConstantApi

This "virtual" case class represents the reflection interface for literal expressions which can not be further broken down or evaluated, such as "true", "0", "classOf[List]".

This "virtual" case class represents the reflection interface for literal expressions which can not be further broken down or evaluated, such as "true", "0", "classOf[List]". Such values become parts of the Scala abstract syntax tree representing the program. The constants correspond to section 6.24 "Constant Expressions" of the Scala Language Specification.

Such constants are used to represent literals in abstract syntax trees (the scala.reflect.api.Trees#Literal node) and literal arguments for Java class file annotations (the scala.reflect.api.Annotations#LiteralArgument class).

Constants can be matched against and can be constructed directly, as if they were case classes:

assert(Constant(true).value == true)
Constant(true) match {
  case Constant(s: String) =>  println("A string: " + s)
  case Constant(b: Boolean) => println("A boolean value: " + b)
  case Constant(x) =>          println("Something else: " + x)
}

Constant instances can wrap certain kinds of these expressions:

Literals of primitive value classes (Byte, Short, Int, Long, Float, Double, Char, Boolean and Unit) - represented directly as the corresponding type
String literals - represented as instances of the String.
References to classes, typically constructed with scala.Predef#classOf - represented as types.
References to enumeration values - represented as symbols.

Class references are represented as instances of scala.reflect.api.Types#Type (because when the Scala compiler processes a class reference, the underlying runtime class might not yet have been compiled). To convert such a reference to a runtime class, one should use the runtimeClass method of a mirror such as RuntimeMirror (the simplest way to get such a mirror is using scala.reflect.runtime.currentMirror).

Enumeration value references are represented as instances of scala.reflect.api.Symbols#Symbol, which on JVM point to methods that return underlying enum values. To inspect an underlying enumeration or to get runtime value of a reference to an enum, one should use a scala.reflect.api.Mirrors#RuntimeMirror (the simplest way to get such a mirror is again scala.reflect.runtime.package#currentMirror).

Usage example:

enum JavaSimpleEnumeration { FOO, BAR }

import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface JavaSimpleAnnotation {
  Class<?> classRef();
  JavaSimpleEnumeration enumRef();
}

@JavaSimpleAnnotation(
  classRef = JavaAnnottee.class,
  enumRef = JavaSimpleEnumeration.BAR
)
public class JavaAnnottee {}

import scala.reflect.runtime.universe._
import scala.reflect.runtime.{currentMirror => cm}

object Test extends App {
  val jann = typeOf[JavaAnnottee].typeSymbol.annotations(0).javaArgs
  def jarg(name: String) = jann(TermName(name)) match {
    // Constant is always wrapped into a Literal or LiteralArgument tree node
    case LiteralArgument(ct: Constant) => value
    case _ => sys.error("Not a constant")
  }

  val classRef = jarg("classRef").value.asInstanceOf[Type]
                                         // ideally one should match instead of casting
  println(showRaw(classRef))             // TypeRef(ThisType(<empty>), JavaAnnottee, List())
  println(cm.runtimeClass(classRef))     // class JavaAnnottee

  val enumRef = jarg("enumRef").value.asInstanceOf[Symbol]
                                         // ideally one should match instead of casting
  println(enumRef)                       // value BAR

  val siblings = enumRef.owner.info.decls
  val enumValues = siblings.filter(sym => sym.isVal && sym.isPublic)
  println(enumValues)                    // Scope{
                                         //   final val FOO: JavaSimpleEnumeration;
                                         //   final val BAR: JavaSimpleEnumeration
                                         // }

  // doesn't work because of https://github.com/scala/bug/issues/6459
  // val enumValue = mirror.reflectField(enumRef.asTerm).get
  val enumClass = cm.runtimeClass(enumRef.owner.asClass)
  val enumValue = enumClass.getDeclaredField(enumRef.name.toString).get(null)
  println(enumValue)                     // BAR
}

Definition Classes: Constants

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
abstract type FlagSet
An abstract type representing sets of flags (like private, final, etc.) that apply to definition trees and symbols
An abstract type representing sets of flags (like private, final, etc.) that apply to definition trees and symbols

Definition Classes
FlagSets
trait FlagValues extends AnyRef
All possible values that can constitute flag sets.
All possible values that can constitute flag sets. The main source of information about flag sets is the scala.reflect.api.FlagSets page.

Definition Classes
FlagSets
trait CompatApi extends AnyRef

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( ... )
abstract type FreeTermSymbol >: Null <: Universe.FreeTermSymbolApi with Universe.TermSymbol
The type of free terms introduced by reification.
The type of free terms introduced by reification.

Definition Classes
Internals
trait FreeTermSymbolApi extends Universe.TermSymbolApi
The API of free term symbols.
The API of free term symbols. The main source of information about symbols is the Symbols page.
$SYMACCESSORS

Definition Classes
Internals
abstract type FreeTypeSymbol >: Null <: Universe.FreeTypeSymbolApi with Universe.TypeSymbol
The type of free types introduced by reification.
The type of free types introduced by reification.

Definition Classes
Internals
trait FreeTypeSymbolApi extends Universe.TypeSymbolApi
The API of free type symbols.
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
abstract type ReferenceToBoxed >: Null <: Universe.ReferenceToBoxedApi with Universe.TermTree
Marks underlying reference to id as boxed.
Marks underlying reference to id as boxed.
Precondition:<\b> id must refer to a captured variable A reference such marked will refer to the boxed entity, no dereferencing with `.elem` is done on it. This tree node can be emitted by macros such as reify that call referenceCapturedVariable. It is eliminated in LambdaLift, where the boxing conversion takes place.

Definition Classes
Internals
trait ReferenceToBoxedApi extends Universe.TermTreeApi
The API that all references support
The API that all references support

Definition Classes
Internals
abstract class ReferenceToBoxedExtractor extends AnyRef
An extractor class to create and pattern match with syntax ReferenceToBoxed(ident).
An extractor class to create and pattern match with syntax ReferenceToBoxed(ident). This AST node does not have direct correspondence to Scala code, and is emitted by macros to reference capture vars directly without going 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
trait TreePrinter extends AnyRef

Attributes
protected
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
abstract type MemberScope >: Null <: Universe.MemberScopeApi with Universe.Scope
The type of member scopes, as in class definitions, for example.
The type of member scopes, as in class definitions, for example.

Definition Classes
Scopes
trait MemberScopeApi extends Universe.ScopeApi
The API that all member scopes support
The API that all member scopes support

Definition Classes
Scopes
abstract type Scope >: Null <: Universe.ScopeApi
The base type of all scopes.
The base type of all scopes.

Definition Classes
Scopes
trait ScopeApi extends Iterable[Universe.Symbol]
The API that all scopes support
The API that all scopes support

Definition Classes
Scopes
trait DefinitionsApi extends Universe.StandardTypes
Defines standard symbols (and types via its base trait).
Defines standard symbols (and types via its base trait).

Definition Classes
StandardDefinitions
trait StandardTypes extends AnyRef
Defines standard types.
Defines standard types.

Definition Classes
StandardDefinitions
trait StandardLiftableInstances extends AnyRef

Definition Classes
StandardLiftables
trait StandardUnliftableInstances extends AnyRef

Definition Classes
StandardLiftables
trait NamesApi extends AnyRef
Defines standard names, common for term and type names: These can be accessed via the nme and tpnme members.
Defines standard names, common for term and type names: These can be accessed via the nme and tpnme members.

Definition Classes
StandardNames
trait TermNamesApi extends Universe.NamesApi
Defines standard term names that can be accessed via the nme member.
Defines standard term names that can be accessed via the nme member.

Definition Classes
StandardNames
trait TypeNamesApi extends Universe.NamesApi
Defines standard type names that can be accessed via the tpnme member.
Defines standard type names that can be accessed via the tpnme member.

Definition Classes
StandardNames
abstract type ClassSymbol >: Null <: Universe.ClassSymbolApi with Universe.TypeSymbol
The type of class symbols representing class and trait definitions.
The type of class symbols representing class and trait definitions.

Definition Classes
Symbols
trait ClassSymbolApi extends Universe.TypeSymbolApi
The API of class symbols.
The API of class symbols. The main source of information about symbols is the Symbols page.
Class Symbol defines isXXX test methods such 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
abstract type MethodSymbol >: Null <: Universe.MethodSymbolApi with Universe.TermSymbol
The type of method symbols representing def declarations.
The type of method symbols representing def declarations.

Definition Classes
Symbols
trait MethodSymbolApi extends Universe.TermSymbolApi
The API of method symbols.
The API of method symbols. The main source of information about symbols is the Symbols page.
Class Symbol defines isXXX test methods such 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
abstract type ModuleSymbol >: Null <: Universe.ModuleSymbolApi with Universe.TermSymbol
The type of module symbols representing object declarations.
The type of module symbols representing object declarations.

Definition Classes
Symbols
trait ModuleSymbolApi extends Universe.TermSymbolApi
The API of module symbols.
The API of module symbols. The main source of information about symbols is the Symbols page.
Class Symbol defines isXXX test methods such 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
abstract type Symbol >: Null <: Universe.SymbolApi
The type of symbols representing declarations.
The type of symbols representing declarations.

Definition Classes
Symbols
trait SymbolApi extends AnyRef
The API of symbols.
The API of symbols. The main source of information about symbols is the Symbols page.
Class Symbol defines isXXX test methods such 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
abstract type TermSymbol >: Null <: Universe.TermSymbolApi with Universe.Symbol
The type of term symbols representing val, var, def, and object declarations as well as packages and value parameters.
The type of term symbols representing val, var, def, and object declarations as well as packages and value parameters.

Definition Classes
Symbols
trait TermSymbolApi extends Universe.SymbolApi
The API of term symbols.
The API of term symbols. The main source of information about symbols is the Symbols page.
Class Symbol defines isXXX test methods such 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
abstract type TypeSymbol >: Null <: Universe.TypeSymbolApi with Universe.Symbol
The type of type symbols representing type, class, and trait declarations, as well as type parameters.
The type of type symbols representing type, class, and trait declarations, as well as type parameters.

Definition Classes
Symbols
trait TypeSymbolApi extends Universe.SymbolApi
The API of type symbols.
The API of type symbols. The main source of information about symbols is the Symbols page.
Class Symbol defines isXXX test methods such 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
abstract type Alternative >: Null <: Universe.AlternativeApi with Universe.TermTree
Alternatives of patterns.
Alternatives of patterns.
Eliminated by compiler phases Eliminated by compiler phases patmat (in the new pattern matcher of 2.10) or explicitouter (in the old pre-2.10 pattern matcher), except for occurrences in encoded Switch stmt (i.e. remaining Match(CaseDef(...)))

Definition Classes
Trees
trait AlternativeApi extends Universe.TermTreeApi
The API that all alternatives support
The API that all alternatives support

Definition Classes
Trees
abstract class AlternativeExtractor extends AnyRef
An extractor class to create and pattern match with syntax Alternative(trees).
An extractor class to create and pattern match with syntax Alternative(trees). This AST node corresponds to the following Scala code:
pat1 | ... | patn

Definition Classes
Trees
abstract type Annotated >: Null <: Universe.AnnotatedApi with Universe.Tree
A tree that has an annotation attached to it.
A tree that has an annotation attached to it. Only used for annotated types and annotation ascriptions, annotations on definitions are stored in the Modifiers. Eliminated by typechecker (typedAnnotated), the annotations are then stored in an AnnotatedType.

Definition Classes
Trees
trait AnnotatedApi extends Universe.TreeApi
The API that all annotateds support
The API that all annotateds support

Definition Classes
Trees
abstract class AnnotatedExtractor extends AnyRef
An extractor class to create and pattern match with syntax Annotated(annot, arg).
An extractor class to create and pattern match with syntax Annotated(annot, arg). This AST node corresponds to the following Scala code:
arg @annot // for types arg: @annot // for exprs

Definition Classes
Trees
abstract type AppliedTypeTree >: Null <: Universe.AppliedTypeTreeApi with Universe.TypTree
Applied type <tpt> [ <args> ], eliminated by RefCheck
Applied type <tpt> [ <args> ], eliminated by RefCheck

Definition Classes
Trees
trait AppliedTypeTreeApi extends Universe.TypTreeApi
The API that all applied type trees support
The API that all applied type trees support

Definition Classes
Trees
abstract class AppliedTypeTreeExtractor extends AnyRef
An extractor class to create and pattern match with syntax AppliedTypeTree(tpt, args).
An extractor class to create and pattern match with syntax AppliedTypeTree(tpt, args). This AST node corresponds to the following Scala code:
tpt[args]
Should only be used with tpt nodes which are types, i.e. which 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
abstract type Apply >: Null <: Universe.ApplyApi with Universe.GenericApply
Value application
Value application

Definition Classes
Trees
trait ApplyApi extends Universe.GenericApplyApi
The API that all applies support
The API that all applies support

Definition Classes
Trees
abstract class ApplyExtractor extends AnyRef
An extractor class to create and pattern match with syntax Apply(fun, args).
An extractor class to create and pattern match with syntax Apply(fun, args). This AST node corresponds to the following Scala code:
fun(args)
For instance:
fun[targs](args)
Is expressed as:
Apply(TypeApply(fun, targs), args)

Definition Classes
Trees
abstract type Assign >: Null <: Universe.AssignApi with Universe.TermTree
Assignment
Assignment

Definition Classes
Trees
trait AssignApi extends Universe.TermTreeApi
The API that all assigns support
The API that all assigns support

Definition Classes
Trees
abstract class AssignExtractor extends AnyRef
An extractor class to create and pattern match with syntax Assign(lhs, rhs).
An extractor class to create and pattern match with syntax Assign(lhs, rhs). This AST node corresponds to the following Scala code:
lhs = rhs

Definition Classes
Trees
abstract type AssignOrNamedArg >: Null <: Universe.AssignOrNamedArgApi with Universe.TermTree
Either an assignment or a named argument.
Either an assignment or a named argument. Only appears in argument lists, eliminated by compiler phase typecheck (doTypedApply), resurrected by reifier.

Definition Classes
Trees
trait AssignOrNamedArgApi extends Universe.TermTreeApi
The API that all assigns support
The API that all assigns support

Definition Classes
Trees
abstract class AssignOrNamedArgExtractor extends AnyRef
An extractor class to create and pattern match with syntax AssignOrNamedArg(lhs, rhs).
An extractor class to create and pattern match with syntax AssignOrNamedArg(lhs, rhs). This AST node corresponds to the following Scala code:
m.f(lhs = rhs)
@annotation(lhs = rhs)

Definition Classes
Trees
abstract type Bind >: Null <: Universe.BindApi with Universe.DefTree
Bind a variable to a rhs pattern.
Bind a variable to a rhs pattern.
Eliminated by compiler phases patmat (in the new pattern matcher of 2.10) or explicitouter (in the old pre-2.10 pattern matcher).

Definition Classes
Trees
trait BindApi extends Universe.DefTreeApi
The API that all binds support
The API that all binds support

Definition Classes
Trees
abstract class BindExtractor extends AnyRef
An extractor class to create and pattern match with syntax Bind(name, body).
An extractor class to create and pattern match with syntax Bind(name, body). This AST node corresponds to the following Scala code:
pat*

Definition Classes
Trees
abstract type Block >: Null <: Universe.BlockApi with Universe.TermTree
Block of expressions (semicolon separated expressions)
Block of expressions (semicolon separated expressions)

Definition Classes
Trees
trait BlockApi extends Universe.TermTreeApi
The API that all blocks support
The API that all blocks support

Definition Classes
Trees
abstract class BlockExtractor extends AnyRef
An extractor class to create and pattern match with syntax Block(stats, expr).
An extractor class to create and pattern match with syntax Block(stats, expr). This AST node corresponds to the following Scala code:
{ stats; expr }
If the block is empty, the expr is set to Literal(Constant(())).

Definition Classes
Trees
abstract type CaseDef >: Null <: Universe.CaseDefApi with Universe.Tree
Case clause in a pattern match.
Case clause in a pattern match. (except for occurrences in switch statements). Eliminated by compiler phases patmat (in the new pattern matcher of 2.10) or explicitouter (in the old pre-2.10 pattern matcher)

Definition Classes
Trees
trait CaseDefApi extends Universe.TreeApi
The API that all case defs support
The API that all case defs support

Definition Classes
Trees
abstract class CaseDefExtractor extends AnyRef
An extractor class to create and pattern match with syntax CaseDef(pat, guard, body).
An extractor class to create and pattern match with syntax CaseDef(pat, guard, body). This AST node corresponds to the following Scala code:
case 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
abstract type ClassDef >: Null <: Universe.ClassDefApi with Universe.ImplDef
A class definition.
A class definition.

Definition Classes
Trees
trait ClassDefApi extends Universe.ImplDefApi
The API that all class defs support
The API that all class defs support

Definition Classes
Trees
abstract class ClassDefExtractor extends AnyRef
An extractor class to create and pattern match with syntax ClassDef(mods, name, tparams, impl).
An extractor class to create and pattern match with syntax ClassDef(mods, name, tparams, impl). This AST node corresponds to the following Scala code:
mods class name [tparams] impl
Where impl stands for:
extends parents { defs }

Definition Classes
Trees
abstract type CompoundTypeTree >: Null <: Universe.CompoundTypeTreeApi with Universe.TypTree
Intersection type <parent1> with ...
Intersection type <parent1> with ... with <parentN> { <decls> }, eliminated by RefCheck

Definition Classes
Trees
trait CompoundTypeTreeApi extends Universe.TypTreeApi
The API that all compound type trees support
The API that all compound type trees support

Definition Classes
Trees
abstract class CompoundTypeTreeExtractor extends AnyRef
An extractor class to create and pattern match with syntax CompoundTypeTree(templ).
An extractor class to create and pattern match with syntax CompoundTypeTree(templ). This AST node corresponds to the following Scala code:
parent1 with ... with parentN { refinement }

Definition Classes
Trees
abstract type DefDef >: Null <: Universe.DefDefApi with Universe.ValOrDefDef
A method or macro definition.
A method or macro definition.

Definition Classes
Trees
trait DefDefApi extends Universe.ValOrDefDefApi
The API that all def defs support
The API that all def defs support

Definition Classes
Trees
abstract class DefDefExtractor extends AnyRef
An extractor class to create and pattern match with syntax DefDef(mods, name, tparams, vparamss, tpt, rhs).
An extractor class to create and pattern match with syntax DefDef(mods, name, tparams, vparamss, tpt, rhs). This AST node corresponds to the following Scala code:
mods def name[tparams](vparams_1)...(vparams_n): tpt = 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
abstract type DefTree >: Null <: Universe.DefTreeApi with Universe.SymTree with Universe.NameTree
A tree representing a symbol-defining entity: 1) A declaration or a definition (type, class, object, package, val, var, or def) 2) Bind that is used to represent binding occurrences in pattern matches 3) LabelDef that is used internally to represent while loops
A tree representing a symbol-defining entity: 1) A declaration or a definition (type, class, object, package, val, var, or def) 2) Bind that is used to represent binding occurrences in pattern matches 3) LabelDef that is used internally to represent while loops

Definition Classes
Trees
trait DefTreeApi extends Universe.SymTreeApi with Universe.NameTreeApi
The API that all def trees support
The API that all def trees support

Definition Classes
Trees
abstract type ExistentialTypeTree >: Null <: Universe.ExistentialTypeTreeApi with Universe.TypTree
Existential type tree node
Existential type tree node

Definition Classes
Trees
trait ExistentialTypeTreeApi extends Universe.TypTreeApi
The API that all existential type trees support
The API that all existential type trees support

Definition Classes
Trees
abstract class ExistentialTypeTreeExtractor extends AnyRef
An extractor class to create and pattern match with syntax ExistentialTypeTree(tpt, whereClauses).
An extractor class to create and pattern match with syntax ExistentialTypeTree(tpt, whereClauses). This AST node corresponds to the following Scala code:
tpt forSome { whereClauses }

Definition Classes
Trees
abstract type Function >: Null <: Universe.FunctionApi with Universe.TermTree with Universe.SymTree
Anonymous function, eliminated by compiler phase lambdalift
Anonymous function, eliminated by compiler phase lambdalift

Definition Classes
Trees
trait FunctionApi extends Universe.TermTreeApi with Universe.SymTreeApi
The API that all functions support
The API that all functions support

Definition Classes
Trees
abstract class FunctionExtractor extends AnyRef
An extractor class to create and pattern match with syntax Function(vparams, body).
An extractor class to create and pattern match with syntax Function(vparams, body). This AST node corresponds to the following Scala code:
vparams => body
The symbol of a Function is a synthetic TermSymbol. It is the owner of the function's parameters.

Definition Classes
Trees
abstract type GenericApply >: Null <: Universe.GenericApplyApi with Universe.TermTree
Common base class for Apply and TypeApply.
Common base class for Apply and TypeApply.

Definition Classes
Trees
trait GenericApplyApi extends Universe.TermTreeApi
The API that all applies support
The API that all applies support

Definition Classes
Trees
abstract type Ident >: Null <: Universe.IdentApi with Universe.RefTree
A reference to identifier name.
A reference to identifier name.

Definition Classes
Trees
trait IdentApi extends Universe.RefTreeApi
The API that all idents support
The API that all idents support

Definition Classes
Trees
abstract class IdentExtractor extends AnyRef
An extractor class to create and pattern match with syntax Ident(qual, name).
An extractor class to create and pattern match with syntax Ident(qual, name). This AST node corresponds to the following Scala code:
name
Type checker converts idents that refer to enclosing fields or methods to selects. For example, name ==> this.name

Definition Classes
Trees
abstract type If >: Null <: Universe.IfApi with Universe.TermTree
Conditional expression
Conditional expression

Definition Classes
Trees
trait IfApi extends Universe.TermTreeApi
The API that all ifs support
The API that all ifs support

Definition Classes
Trees
abstract class IfExtractor extends AnyRef
An extractor class to create and pattern match with syntax If(cond, thenp, elsep).
An extractor class to create and pattern match with syntax If(cond, thenp, elsep). This AST node corresponds to the following Scala code:
if (cond) thenp else elsep
If the alternative is not present, the elsep is set to Literal(Constant(())).

Definition Classes
Trees
abstract type ImplDef >: Null <: Universe.ImplDefApi with Universe.MemberDef
A common base class for class and object definitions.
A common base class for class and object definitions.

Definition Classes
Trees
trait ImplDefApi extends Universe.MemberDefApi
The API that all impl defs support
The API that all impl defs support

Definition Classes
Trees
abstract type Import >: Null <: Universe.ImportApi with Universe.SymTree
Import clause
Import clause

Definition Classes
Trees
trait ImportApi extends Universe.SymTreeApi
The API that all imports support
The API that all imports support

Definition Classes
Trees
abstract class ImportExtractor extends AnyRef
An extractor class to create and pattern match with syntax Import(expr, selectors).
An extractor class to create and pattern match with syntax Import(expr, selectors). This AST node corresponds to the following Scala code:
import expr.{selectors}
Selectors are a list of ImportSelectors, which conceptually are pairs of names (from, to). The last (and maybe only name) may be a nme.WILDCARD. For instance:
import qual.{x, y => z, _}
Would be represented as:
Import(qual, List(("x", "x"), ("y", "z"), (WILDCARD, null)))
The symbol of an Import is an import symbol @see Symbol.newImport. It's used primarily as a marker to check that the import has been typechecked.

Definition Classes
Trees
abstract type ImportSelector >: Null <: Universe.ImportSelectorApi
Import selector (not a tree, but a component of the Import tree)
Import selector (not a tree, but a component of the Import tree)
Representation of an imported name its optional rename and their optional positions
Eliminated by typecheck.

Definition Classes
Trees
trait ImportSelectorApi extends AnyRef
The API that all import selectors support
The API that all import selectors support

Definition Classes
Trees
abstract class ImportSelectorExtractor extends AnyRef
An extractor class to create and pattern match with syntax ImportSelector(name:, namePos, rename, renamePos).
An extractor class to create and pattern match with syntax ImportSelector(name:, namePos, rename, renamePos). This is not an AST node, it is used as a part of the Import node.

Definition Classes
Trees
abstract type LabelDef >: Null <: Universe.LabelDefApi with Universe.DefTree with Universe.TermTree
A labelled expression.
A labelled expression. Not expressible in language syntax, but generated by the compiler to simulate while/do-while loops, and also by the pattern matcher.
The label acts much like a nested function, where params represents the incoming parameters. The symbol given to the LabelDef should have a MethodType, as if it were a nested function.
Jumps are apply nodes attributed with a label's symbol. The arguments from the apply node will be passed to the label and assigned to the Idents.
Forward jumps within a block are allowed.

Definition Classes
Trees
trait LabelDefApi extends Universe.DefTreeApi with Universe.TermTreeApi
The API that all label defs support
The API that all label defs support

Definition Classes
Trees
abstract class LabelDefExtractor extends AnyRef
An extractor class to create and pattern match with syntax LabelDef(name, params, rhs).
An extractor class to create and pattern match with syntax LabelDef(name, params, rhs).
This AST node does not have direct correspondence to Scala code. It is used for tailcalls and like. For example, while/do are desugared to label defs as follows:
while (cond) body ==> LabelDef($L, List(), if (cond) { body; L$() } else ())
do body while (cond) ==> LabelDef($L, List(), body; if (cond) L$() else ())

Definition Classes
Trees
abstract type Literal >: Null <: Universe.LiteralApi with Universe.TermTree
Literal
Literal

Definition Classes
Trees
trait LiteralApi extends Universe.TermTreeApi
The API that all literals support
The API that all literals support

Definition Classes
Trees
abstract class LiteralExtractor extends AnyRef
An extractor class to create and pattern match with syntax Literal(value).
An extractor class to create and pattern match with syntax Literal(value). This AST node corresponds to the following Scala code:
value

Definition Classes
Trees
abstract type Match >: Null <: Universe.MatchApi with Universe.TermTree
- Pattern matching expression (before compiler phase explicitouter before 2.10 / patmat from 2.10)
- Pattern matching expression (before compiler phase explicitouter before 2.10 / patmat from 2.10)
Switch statements (after compiler phase explicitouter before 2.10 / patmat from 2.10)
After compiler phase explicitouter before 2.10 / patmat from 2.10, cases will satisfy the following constraints:
all guards are EmptyTree,
all patterns will be either Literal(Constant(x:Int)) or Alternative(lit|...|lit)
except for an "otherwise" branch, which has pattern Ident(nme.WILDCARD)

Definition Classes
Trees
trait MatchApi extends Universe.TermTreeApi
The API that all matches support
The API that all matches support

Definition Classes
Trees
abstract class MatchExtractor extends AnyRef
An extractor class to create and pattern match with syntax Match(selector, cases).
An extractor class to create and pattern match with syntax Match(selector, cases). This AST node corresponds to the following Scala code:
selector match { cases }
Match is also used in pattern matching assignments like val (foo, bar) = baz.

Definition Classes
Trees
abstract type MemberDef >: Null <: Universe.MemberDefApi with Universe.DefTree
Common base class for all member definitions: types, classes, objects, packages, vals and vars, defs.
Common base class for all member definitions: types, classes, objects, packages, vals and vars, defs.

Definition Classes
Trees
trait MemberDefApi extends Universe.DefTreeApi
The API that all member defs support
The API that all member defs support

Definition Classes
Trees
abstract class ModifiersApi extends AnyRef
The API that all Modifiers support
The API that all Modifiers support

Definition Classes
Trees
abstract class ModifiersExtractor extends AnyRef
An extractor class to create and pattern match with syntax Modifiers(flags, privateWithin, annotations).
An extractor class to create and pattern match with syntax Modifiers(flags, privateWithin, annotations). Modifiers encapsulate flags, visibility annotations and Scala annotations for member definitions.

Definition Classes
Trees
abstract type ModuleDef >: Null <: Universe.ModuleDefApi with Universe.ImplDef
An object definition, e.g.
An object definition, e.g. object Foo. Internally, objects are quite frequently called modules to reduce ambiguity. Eliminated by compiler phase refcheck.

Definition Classes
Trees
trait ModuleDefApi extends Universe.ImplDefApi
The API that all module defs support
The API that all module defs support

Definition Classes
Trees
abstract class ModuleDefExtractor extends AnyRef
An extractor class to create and pattern match with syntax ModuleDef(mods, name, impl).
An extractor class to create and pattern match with syntax ModuleDef(mods, name, impl). This AST node corresponds to the following Scala code:
mods object name impl
Where impl stands for:
extends parents { defs }

Definition Classes
Trees
abstract type NameTree >: Null <: Universe.NameTreeApi with Universe.Tree
A tree that carries a name, e.g.
A tree that carries a name, e.g. by defining it (DefTree) or by referring to it (RefTree).

Definition Classes
Trees
trait NameTreeApi extends Universe.TreeApi
The API that all name trees support
The API that all name trees support

Definition Classes
Trees
abstract type New >: Null <: Universe.NewApi with Universe.TermTree
Object instantiation
Object instantiation

Definition Classes
Trees
trait NewApi extends Universe.TermTreeApi
The API that all news support
The API that all news support

Definition Classes
Trees
abstract class NewExtractor extends AnyRef
An extractor class to create and pattern match with syntax New(tpt).
An extractor class to create and pattern match with syntax New(tpt). This AST node corresponds to the following Scala code:
new 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
abstract type PackageDef >: Null <: Universe.PackageDefApi with Universe.MemberDef
A packaging, such as package pid { stats }
A packaging, such as package pid { stats }

Definition Classes
Trees
trait PackageDefApi extends Universe.MemberDefApi
The API that all package defs support
The API that all package defs support

Definition Classes
Trees
abstract class PackageDefExtractor extends AnyRef
An extractor class to create and pattern match with syntax PackageDef(pid, stats).
An extractor class to create and pattern match with syntax PackageDef(pid, stats). This AST node corresponds to the following Scala code:
package pid { stats }

Definition Classes
Trees
abstract type RefTree >: Null <: Universe.RefTreeApi with Universe.SymTree with Universe.NameTree
A tree which references a symbol-carrying entity.
A tree which references a symbol-carrying entity. References one, as opposed to defining one; definitions are in DefTrees.

Definition Classes
Trees
trait RefTreeApi extends Universe.SymTreeApi with Universe.NameTreeApi
The API that all ref trees support
The API that all ref trees support

Definition Classes
Trees
abstract class RefTreeExtractor extends AnyRef
An extractor class to create and pattern match with syntax RefTree(qual, name).
An extractor class to create and pattern match with syntax RefTree(qual, name). This AST node corresponds to either Ident, Select or SelectFromTypeTree.

Definition Classes
Trees
abstract type Return >: Null <: Universe.ReturnApi with Universe.SymTree with Universe.TermTree
Return expression
Return expression

Definition Classes
Trees
trait ReturnApi extends Universe.TermTreeApi
The API that all returns support
The API that all returns support

Definition Classes
Trees
abstract class ReturnExtractor extends AnyRef
An extractor class to create and pattern match with syntax Return(expr).
An extractor class to create and pattern match with syntax Return(expr). This AST node corresponds to the following Scala code:
return expr
The symbol of a Return node is the enclosing method.

Definition Classes
Trees
abstract type Select >: Null <: Universe.SelectApi with Universe.RefTree
A member selection <qualifier> .
A member selection <qualifier> . <name>

Definition Classes
Trees
trait SelectApi extends Universe.RefTreeApi
The API that all selects support
The API that all selects support

Definition Classes
Trees
abstract class SelectExtractor extends AnyRef
An extractor class to create and pattern match with syntax Select(qual, name).
An extractor class to create and pattern match with syntax Select(qual, name). This AST node corresponds to the following Scala code:
qualifier.selector
Should only be used with qualifier nodes which are terms, i.e. which 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
abstract type SelectFromTypeTree >: Null <: Universe.SelectFromTypeTreeApi with Universe.TypTree with Universe.RefTree
Type selection <qualifier> # <name>, eliminated by RefCheck
Type selection <qualifier> # <name>, eliminated by RefCheck

Definition Classes
Trees
trait SelectFromTypeTreeApi extends Universe.TypTreeApi with Universe.RefTreeApi
The API that all selects from type trees support
The API that all selects from type trees support

Definition Classes
Trees
abstract class SelectFromTypeTreeExtractor extends AnyRef
An extractor class to create and pattern match with syntax SelectFromTypeTree(qualifier, name).
An extractor class to create and pattern match with syntax SelectFromTypeTree(qualifier, name). This AST node corresponds to the following Scala code:
qualifier # selector
Note: a path-dependent type p.T is expressed as p.type # T
Should only be used with qualifier nodes which are types, i.e. which 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
abstract type SingletonTypeTree >: Null <: Universe.SingletonTypeTreeApi with Universe.TypTree
Singleton type, eliminated by RefCheck
Singleton type, eliminated by RefCheck

Definition Classes
Trees
trait SingletonTypeTreeApi extends Universe.TypTreeApi
The API that all singleton type trees support
The API that all singleton type trees support

Definition Classes
Trees
abstract class SingletonTypeTreeExtractor extends AnyRef
An extractor class to create and pattern match with syntax SingletonTypeTree(ref).
An extractor class to create and pattern match with syntax SingletonTypeTree(ref). This AST node corresponds to the following Scala code:
ref.type

Definition Classes
Trees
abstract type Star >: Null <: Universe.StarApi with Universe.TermTree
Repetition of pattern.
Repetition of pattern.
Eliminated by compiler phases patmat (in the new pattern matcher of 2.10) or explicitouter (in the old pre-2.10 pattern matcher).

Definition Classes
Trees
trait StarApi extends Universe.TermTreeApi
The API that all stars support
The API that all stars support

Definition Classes
Trees
abstract class StarExtractor extends AnyRef
An extractor class to create and pattern match with syntax Star(elem).
An extractor class to create and pattern match with syntax Star(elem). This AST node corresponds to the following Scala code:
pat*

Definition Classes
Trees
abstract type Super >: Null <: Universe.SuperApi with Universe.TermTree
Super reference, where qual is the corresponding this reference.
Super reference, where qual is the corresponding this reference. A super reference C.super[M] is represented as Super(This(C), M).

Definition Classes
Trees
trait SuperApi extends Universe.TermTreeApi
The API that all supers support
The API that all supers support

Definition Classes
Trees
abstract class SuperExtractor extends AnyRef
An extractor class to create and pattern match with syntax Super(qual, mix).
An extractor class to create and pattern match with syntax Super(qual, mix). This AST node corresponds to the following Scala code:
C.super[M]
Which is represented as:
Super(This(C), M)
If mix is empty, it is tpnme.EMPTY.
The symbol of a Super is the class _from_ which the super reference is made. For instance in C.super(...), it would be C.

Definition Classes
Trees
abstract type SymTree >: Null <: Universe.SymTreeApi with Universe.Tree
A tree that carries a symbol, e.g.
A tree that carries a symbol, e.g. by defining it (DefTree) or by referring to it (RefTree). Such trees start their life naked, returning NoSymbol, but after being typechecked without errors they hold non-empty symbols.

Definition Classes
Trees
trait SymTreeApi extends Universe.TreeApi
The API that all sym trees support
The API that all sym trees support

Definition Classes
Trees
abstract type Template >: Null <: Universe.TemplateApi with Universe.SymTree
Instantiation template of a class or trait
Instantiation template of a class or trait

Definition Classes
Trees
trait TemplateApi extends Universe.SymTreeApi
The API that all templates support
The API that all templates support

Definition Classes
Trees
abstract class TemplateExtractor extends AnyRef
An extractor class to create and pattern match with syntax Template(parents, self, body).
An extractor class to create and pattern match with syntax Template(parents, self, body). This AST node corresponds to the following Scala code:
extends parents { self => body }
In case when the self-type annotation is missing, it is represented as an empty value definition with nme.WILDCARD as name and NoType as type.
The symbol of a template is a local dummy. @see Symbol.newLocalDummy The owner of the local dummy is the enclosing trait or class. The local dummy is itself the owner of any local blocks. For example:
class C { def foo { // owner is C def bar // owner is local dummy } }

Definition Classes
Trees
abstract type TermTree >: Null <: Universe.TermTreeApi with Universe.Tree
A tree for a term.
A tree for a term. Not all trees representing terms are TermTrees; use isTerm to reliably identify terms.

Definition Classes
Trees
trait TermTreeApi extends Universe.TreeApi
The API that all term trees support
The API that all term trees support

Definition Classes
Trees
abstract type This >: Null <: Universe.ThisApi with Universe.TermTree with Universe.SymTree
Self reference
Self reference

Definition Classes
Trees
trait ThisApi extends Universe.TermTreeApi with Universe.SymTreeApi
The API that all thises support
The API that all thises support

Definition Classes
Trees
abstract class ThisExtractor extends AnyRef
An extractor class to create and pattern match with syntax This(qual).
An extractor class to create and pattern match with syntax This(qual). This AST node corresponds to the following Scala code:
qual.this
The symbol of a This is the class to which the this refers. For instance in C.this, it would be C.

Definition Classes
Trees
abstract type Throw >: Null <: Universe.ThrowApi with Universe.TermTree
Throw expression
Throw expression

Definition Classes
Trees
trait ThrowApi extends Universe.TermTreeApi
The API that all tries support
The API that all tries support

Definition Classes
Trees
abstract class ThrowExtractor extends AnyRef
An extractor class to create and pattern match with syntax Throw(expr).
An extractor class to create and pattern match with syntax Throw(expr). This AST node corresponds to the following Scala code:
throw expr

Definition Classes
Trees
abstract class Transformer extends AnyRef
A class that implement a default tree transformation strategy: breadth-first component-wise cloning.
A class that implement a default tree transformation strategy: breadth-first component-wise cloning.

Definition Classes
Trees
class Traverser extends AnyRef
A class that implement a default tree traversal strategy: breadth-first component-wise.
A class that implement a default tree traversal strategy: breadth-first component-wise.

Definition Classes
Trees
abstract type Tree >: Null <: Universe.TreeApi
The type of Scala abstract syntax trees.
The type of Scala abstract syntax trees.

Definition Classes
Trees
trait TreeApi extends Product
The API that all trees support.
The API that all trees support. The main source of information about trees is the scala.reflect.api.Trees page.

Definition Classes
Trees
abstract type TreeCopier >: Null <: Universe.TreeCopierOps
The type of standard (lazy) tree copiers.
The type of standard (lazy) tree copiers.

Definition Classes
Trees
abstract class TreeCopierOps extends AnyRef
The API of a tree copier.
The API of a tree copier.

Definition Classes
Trees
abstract type Try >: Null <: Universe.TryApi with Universe.TermTree
Try catch node
Try catch node

Definition Classes
Trees
trait TryApi extends Universe.TermTreeApi
The API that all tries support
The API that all tries support

Definition Classes
Trees
abstract class TryExtractor extends AnyRef
An extractor class to create and pattern match with syntax Try(block, catches, finalizer).
An extractor class to create and pattern match with syntax Try(block, catches, finalizer). This AST node corresponds to the following Scala code:
try block catch { catches } finally finalizer
If the finalizer is not present, the finalizer is set to EmptyTree.

Definition Classes
Trees
abstract type TypTree >: Null <: Universe.TypTreeApi with Universe.Tree
A tree for a type.
A tree for a type. Not all trees representing types are TypTrees; use isType to reliably identify types.

Definition Classes
Trees
trait TypTreeApi extends Universe.TreeApi
The API that all typ trees support
The API that all typ trees support

Definition Classes
Trees
abstract type TypeApply >: Null <: Universe.TypeApplyApi with Universe.GenericApply
Explicit type application.
Explicit type application.

Definition Classes
Trees
trait TypeApplyApi extends Universe.GenericApplyApi
The API that all type applies support
The API that all type applies support

Definition Classes
Trees
abstract class TypeApplyExtractor extends AnyRef
An extractor class to create and pattern match with syntax TypeApply(fun, args).
An extractor class to create and pattern match with syntax TypeApply(fun, args). This AST node corresponds to the following Scala code:
fun[args]
Should only be used with fun nodes which are terms, i.e. which 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
abstract type TypeBoundsTree >: Null <: Universe.TypeBoundsTreeApi with Universe.TypTree
Type bounds tree node
Type bounds tree node

Definition Classes
Trees
trait TypeBoundsTreeApi extends Universe.TypTreeApi
The API that all type bound trees support
The API that all type bound trees support

Definition Classes
Trees
abstract class TypeBoundsTreeExtractor extends AnyRef
An extractor class to create and pattern match with syntax TypeBoundsTree(lo, hi).
An extractor class to create and pattern match with syntax TypeBoundsTree(lo, hi). This AST node corresponds to the following Scala code:
>: lo <: hi

Definition Classes
Trees
abstract type TypeDef >: Null <: Universe.TypeDefApi with Universe.MemberDef
An abstract type, a type parameter, or a type alias.
An abstract type, a type parameter, or a type alias. Eliminated by erasure.

Definition Classes
Trees
trait TypeDefApi extends Universe.MemberDefApi
The API that all type defs support
The API that all type defs support

Definition Classes
Trees
abstract class TypeDefExtractor extends AnyRef
An extractor class to create and pattern match with syntax TypeDef(mods, name, tparams, rhs).
An extractor class to create and pattern match with syntax TypeDef(mods, name, tparams, rhs). This AST node corresponds to the following Scala code:
mods type name[tparams] = 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
abstract type TypeTree >: Null <: Universe.TypeTreeApi with Universe.TypTree
A synthetic tree holding an arbitrary type.
A synthetic tree holding an arbitrary type. Not to be confused with with TypTree, the trait for trees that are only used for type trees. TypeTree's are inserted in several places, but most notably in RefCheck, where the arbitrary type trees are all replaced by TypeTree's.

Definition Classes
Trees
trait TypeTreeApi extends Universe.TypTreeApi
The API that all type trees support
The API that all type trees support

Definition Classes
Trees
abstract class TypeTreeExtractor extends AnyRef
An extractor class to create and pattern match with syntax TypeTree().
An extractor class to create and pattern match with syntax TypeTree(). This AST node does not have direct correspondence to Scala code, and is emitted by everywhere when we want to wrap a Type in a Tree.

Definition Classes
Trees
abstract type Typed >: Null <: Universe.TypedApi with Universe.TermTree
Type annotation, eliminated by compiler phase cleanup
Type annotation, eliminated by compiler phase cleanup

Definition Classes
Trees
trait TypedApi extends Universe.TermTreeApi
The API that all typeds support
The API that all typeds support

Definition Classes
Trees
abstract class TypedExtractor extends AnyRef
An extractor class to create and pattern match with syntax Typed(expr, tpt).
An extractor class to create and pattern match with syntax Typed(expr, tpt). This AST node corresponds to the following Scala code:
expr: tpt

Definition Classes
Trees

abstract type UnApply >: Null <: Universe.UnApplyApi with Universe.TermTree
Used to represent unapply methods in pattern matching.
Used to represent unapply methods in pattern matching.
For example:
2 match { case Foo(x) => x }
Is represented as:
Match( Literal(Constant(2)), List( CaseDef( UnApply( // a dummy node that carries the type of unapplication to patmat // the <unapply-selector> here doesn't have an underlying symbol // it only has a type assigned, therefore after `untypecheck` this tree is no longer typeable Apply(Select(Ident(Foo), TermName("unapply")), List(Ident(TermName("<unapply-selector>")))), // arguments of the unapply => nothing synthetic here List(Bind(TermName("x"), Ident(nme.WILDCARD)))), EmptyTree, Ident(TermName("x")))))
Introduced by typer. Eliminated by compiler phases patmat (in the new pattern matcher of 2.10) or explicitouter (in the old pre-2.10 pattern matcher).

Definition Classes
Trees

trait UnApplyApi extends Universe.TermTreeApi
The API that all unapplies support
The API that all unapplies support

Definition Classes
Trees
abstract class UnApplyExtractor extends AnyRef
An extractor class to create and pattern match with syntax UnApply(fun, args).
An extractor class to create and pattern match with syntax UnApply(fun, args). This AST node does not have direct correspondence to Scala code, and is introduced when typechecking pattern matches and try blocks.

Definition Classes
Trees
abstract type ValDef >: Null <: Universe.ValDefApi with Universe.ValOrDefDef
Broadly speaking, a value definition.
Broadly speaking, a value definition. All these are encoded as ValDefs:
immutable values, e.g. "val x"
mutable values, e.g. "var x" - the MUTABLE flag set in mods
lazy values, e.g. "lazy val x" - the LAZY flag set in mods
method parameters, see vparamss in scala.reflect.api.Trees#DefDef - the PARAM flag is set in mods
explicit self-types, e.g. class A { self: Bar => }

Definition Classes
Trees
trait ValDefApi extends Universe.ValOrDefDefApi
The API that all val defs support
The API that all val defs support

Definition Classes
Trees
abstract class ValDefExtractor extends AnyRef
An extractor class to create and pattern match with syntax ValDef(mods, name, tpt, rhs).
An extractor class to create and pattern match with syntax ValDef(mods, name, tpt, rhs). This AST node corresponds to any of the following Scala code:
mods val name: tpt = 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
abstract type ValOrDefDef >: Null <: Universe.ValOrDefDefApi with Universe.MemberDef
A common base class for ValDefs and DefDefs.
A common base class for ValDefs and DefDefs.

Definition Classes
Trees
trait ValOrDefDefApi extends Universe.MemberDefApi
The API that all val defs and def defs support
The API that all val defs and def defs support

Definition Classes
Trees
trait TypeTag[T] extends Universe.WeakTypeTag[T] with Equals with Serializable
A TypeTag is a scala.reflect.api.TypeTags#WeakTypeTag with the additional static guarantee that all type references are concrete, i.e.
A TypeTag is a scala.reflect.api.TypeTags#WeakTypeTag with the additional static guarantee that all type references are concrete, i.e. it does not contain any references to unresolved type parameters or abstract types.

Definition Classes
TypeTags
Annotations
@implicitNotFound( "No TypeTag available for ${T}" )
See also
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
abstract type AnnotatedType >: Null <: Universe.AnnotatedTypeApi with Universe.Type
The AnnotatedType type signature is used for annotated types of the for <type> @<annotation>.
The AnnotatedType type signature is used for annotated types of the for <type> @<annotation>.

Definition Classes
Types
trait AnnotatedTypeApi extends Universe.TypeApi
The API that all annotated types support.
The API that all annotated types support. The main source of information about types is the scala.reflect.api.Types page.

Definition Classes
Types
abstract class AnnotatedTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax AnnotatedType(annotations, underlying).
An extractor class to create and pattern match with syntax AnnotatedType(annotations, underlying). Here, annotations are the annotations decorating the underlying type underlying. selfSym is a symbol representing the annotated type itself.

Definition Classes
Types
abstract type BoundedWildcardType >: Null <: Universe.BoundedWildcardTypeApi with Universe.Type
BoundedWildcardTypes, used only during type inference, are created in two places:
BoundedWildcardTypes, used only during type inference, are created in two places:
If the expected type of an expression is an existential type, its hidden symbols are replaced with bounded wildcards. 2. When an implicit conversion is being sought based in part on the name of a method in the converted type, a HasMethodMatching type is created: a MethodType with parameters typed as BoundedWildcardTypes.

Definition Classes
Types
trait BoundedWildcardTypeApi extends Universe.TypeApi
The API that all this types support.
The API that all this types support. The main source of information about types is the scala.reflect.api.Types page.

Definition Classes
Types
abstract class BoundedWildcardTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax BoundedWildcardTypeExtractor(bounds) 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
abstract type ClassInfoType >: Null <: Universe.ClassInfoTypeApi with Universe.CompoundType
The ClassInfo type signature is used to define parents and declarations of classes, traits, and objects.
The ClassInfo type signature is used to define parents and declarations of classes, traits, and objects. If a class, trait, or object C is declared like this
C extends P_1 with ... with P_m { D_1; ...; D_n}
its ClassInfo type has the following form:
ClassInfo(List(P_1, ..., P_m), Scope(D_1, ..., D_n), C)

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
abstract type CompoundType >: Null <: Universe.CompoundTypeApi with Universe.Type
A subtype of Type representing refined types as well as ClassInfo signatures.
A subtype of Type representing refined types as well as ClassInfo signatures.

Definition Classes
Types
trait CompoundTypeApi extends AnyRef
Has no special methods.
Has no special methods. Is here to provides erased identity for CompoundType.

Definition Classes
Types
abstract type ConstantType >: Null <: Universe.ConstantTypeApi with Universe.SingletonType
The ConstantType type is not directly written in user programs, but arises as the type of a constant.
The ConstantType type is not directly written in user programs, but arises as the type of a constant. The REPL expresses constant types like Int(11). Here are some constants with their types:
1 ConstantType(Constant(1)) "abc" ConstantType(Constant("abc"))

Definition Classes
Types
trait ConstantTypeApi extends Universe.TypeApi
The API that all constant types support.
The API that all constant types support. The main source of information about types is the scala.reflect.api.Types page.

Definition Classes
Types
abstract class ConstantTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax ConstantType(constant) Here, constant is the constant value represented by the type.
An extractor class to create and pattern match with syntax ConstantType(constant) Here, constant is the constant value represented by the type.

Definition Classes
Types
abstract type ExistentialType >: Null <: Universe.ExistentialTypeApi with Universe.Type
The ExistentialType type signature is used for existential types and wildcard types.
The ExistentialType type signature is used for existential types and wildcard types.

Definition Classes
Types
trait ExistentialTypeApi extends Universe.TypeApi
The API that all existential types support.
The API that all existential types support. The main source of information about types is the scala.reflect.api.Types page.

Definition Classes
Types
abstract class ExistentialTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax ExistentialType(quantified, underlying).
An extractor class to create and pattern match with syntax ExistentialType(quantified, underlying). Here, quantified are the type variables bound by the existential type and underlying is the type that's existentially quantified.

Definition Classes
Types
abstract type MethodType >: Null <: Universe.MethodTypeApi with Universe.Type
The MethodType type signature is used to indicate parameters and result type of a method
The MethodType type signature is used to indicate parameters and result type of a method

Definition Classes
Types
trait MethodTypeApi extends Universe.TypeApi
The API that all method types support.
The API that all method types support. The main source of information about types is the scala.reflect.api.Types page.

Definition Classes
Types
abstract class MethodTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax MethodType(params, restpe) Here, params is a potentially empty list of parameter symbols of the method, 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
abstract type NullaryMethodType >: Null <: Universe.NullaryMethodTypeApi with Universe.Type
The NullaryMethodType type signature is used for parameterless methods with declarations of the form def foo: T
The NullaryMethodType type signature is used for parameterless methods with declarations of the form def foo: T

Definition Classes
Types
trait NullaryMethodTypeApi extends Universe.TypeApi
The API that all nullary method types support.
The API that all nullary method types support. The main source of information about types is the scala.reflect.api.Types page.

Definition Classes
Types
abstract class NullaryMethodTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax NullaryMethodType(resultType).
An extractor class to create and pattern match with syntax NullaryMethodType(resultType). Here, resultType is the result type of the parameterless method.

Definition Classes
Types
abstract type PolyType >: Null <: Universe.PolyTypeApi with Universe.Type
The PolyType type signature is used for polymorphic methods that have at least one type parameter.
The PolyType type signature is used for polymorphic methods that have at least one type parameter.

Definition Classes
Types
trait PolyTypeApi extends Universe.TypeApi
The API that all polymorphic types support.
The API that all polymorphic types support. The main source of information about types is the scala.reflect.api.Types page.

Definition Classes
Types
abstract class PolyTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax PolyType(typeParams, resultType).
An extractor class to create and pattern match with syntax PolyType(typeParams, resultType). Here, typeParams are the type parameters of the method and resultType is the type signature following the type parameters.

Definition Classes
Types
abstract type RefinedType >: Null <: Universe.RefinedTypeApi with Universe.CompoundType
The RefinedType type defines types of any of the forms on the left, with their RefinedType representations to the right.
The RefinedType type defines types of any of the forms on the left, with their RefinedType representations to the right.
P_1 with ... with P_m { D_1; ...; D_n} RefinedType(List(P_1, ..., P_m), Scope(D_1, ..., D_n)) P_1 with ... with P_m RefinedType(List(P_1, ..., P_m), Scope()) { D_1; ...; D_n} RefinedType(List(AnyRef), Scope(D_1, ..., D_n))

Definition Classes
Types
trait RefinedTypeApi extends Universe.TypeApi
The API that all refined types support.
The API that all refined types support. The main source of information about types is the scala.reflect.api.Types page.

Definition Classes
Types
abstract class RefinedTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax RefinedType(parents, decls) Here, parents is the list of parent types of the class, 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
abstract type SingleType >: Null <: Universe.SingleTypeApi with Universe.SingletonType
The SingleType type describes types of any of the forms on the left, with their TypeRef representations to the right.
The SingleType type describes types of any of the forms on the left, with their TypeRef representations to the right.
(T # x).type SingleType(T, x) p.x.type SingleType(p.type, x) x.type SingleType(NoPrefix, x)

Definition Classes
Types
trait SingleTypeApi extends Universe.TypeApi
The API that all single types support.
The API that all single types support. The main source of information about types is the scala.reflect.api.Types page.

Definition Classes
Types
abstract class SingleTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax SingleType(pre, sym) Here, pre is the prefix of the single-type, 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
abstract type SingletonType >: Null <: Universe.SingletonTypeApi with Universe.Type
The type of Scala singleton types, i.e., types that are inhabited by only one nun-null value.
The type of Scala singleton types, i.e., types that are inhabited by only one nun-null value. These include types of the forms
C.this.type C.super.type x.type
as well as constant types.

Definition Classes
Types
trait SingletonTypeApi extends AnyRef
Has no special methods.
Has no special methods. Is here to provides erased identity for SingletonType.

Definition Classes
Types
abstract type SuperType >: Null <: Universe.SuperTypeApi with Universe.SingletonType
The SuperType type is not directly written, but arises when C.super is used as a prefix in a TypeRef or SingleType.
The SuperType type is not directly written, but arises when C.super is used as a prefix in a TypeRef or SingleType. It's internal presentation is
SuperType(thistpe, supertpe)
Here, thistpe is the type of the corresponding this-type. For instance, in the type arising from C.super, the thistpe part would be ThisType(C). supertpe is the type of the super class referred to by the super.

Definition Classes
Types
trait SuperTypeApi extends Universe.TypeApi
The API that all super types support.
The API that all super types support. The main source of information about types is the scala.reflect.api.Types page.

Definition Classes
Types
abstract class SuperTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax SingleType(thistpe, supertpe)
An extractor class to create and pattern match with syntax SingleType(thistpe, supertpe)

Definition Classes
Types
abstract type ThisType >: Null <: Universe.ThisTypeApi with Universe.SingletonType
A singleton type that describes types of the form on the left with the corresponding ThisType representation to the right:
A singleton type that describes types of the form on the left with the corresponding ThisType representation to the right:
C.this.type ThisType(C)

Definition Classes
Types
trait ThisTypeApi extends Universe.TypeApi
The API that all this types support.
The API that all this types support. The main source of information about types is the scala.reflect.api.Types page.

Definition Classes
Types
abstract class ThisTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax ThisType(sym) 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 type Type >: Null <: Universe.TypeApi
The type of Scala types, and also Scala type signatures.
The type of Scala types, and also Scala type signatures. (No difference is internally made between the two).

Definition Classes
Types
abstract class TypeApi extends AnyRef
The API of types.
The API of types. The main source of information about types is the scala.reflect.api.Types page.

Definition Classes
Types
abstract type TypeBounds >: Null <: Universe.TypeBoundsApi with Universe.Type
The TypeBounds type signature is used to indicate lower and upper type bounds of type parameters and abstract types.
The TypeBounds type signature is used to indicate lower and upper type bounds of type parameters and abstract types. It is not a first-class type. If an abstract type or type parameter is declared with any of the forms on the left, its type signature is the TypeBounds type on the right.
T >: L <: U TypeBounds(L, U) T >: L TypeBounds(L, Any) T <: U TypeBounds(Nothing, U)

Definition Classes
Types
trait TypeBoundsApi extends Universe.TypeApi
The API that all type bounds support.
The API that all type bounds support. The main source of information about types is the scala.reflect.api.Types page.

Definition Classes
Types
abstract class TypeBoundsExtractor extends AnyRef
An extractor class to create and pattern match with syntax TypeBound(lower, upper) Here, lower is the lower bound of 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

abstract type TypeRef >: Null <: Universe.TypeRefApi with Universe.Type
The TypeRef type describes types of any of the forms on the left, with their TypeRef representations to the right.
The TypeRef type describes types of any of the forms on the left, with their TypeRef representations to the right.
T # C[T_1, ..., T_n] TypeRef(T, C, List(T_1, ..., T_n)) p.C[T_1, ..., T_n] TypeRef(p.type, C, List(T_1, ..., T_n)) C[T_1, ..., T_n] TypeRef(NoPrefix, C, List(T_1, ..., T_n)) T # C TypeRef(T, C, Nil) p.C TypeRef(p.type, C, Nil) C TypeRef(NoPrefix, C, Nil)

Definition Classes
Types

trait TypeRefApi extends Universe.TypeApi
The API that all type refs support.
The API that all type refs support. The main source of information about types is the scala.reflect.api.Types page.

Definition Classes
Types
abstract class TypeRefExtractor extends AnyRef
An extractor class to create and pattern match with syntax TypeRef(pre, sym, args) Here, pre is the prefix of the type reference, sym is the symbol referred to by the type reference, 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
abstract type Compat <: CompatApi

Definition Classes
Internals
See also
compat
abstract type Internal <: InternalApi

Definition Classes
Internals
See also
InternalApi
abstract type Mirror >: Null <: api.Mirror[Universe.this.type]
The base type of all mirrors of this universe.
The base type of all mirrors of this universe.
This abstract type conforms the base interface for all mirrors defined in scala.reflect.api.Mirror and is gradually refined in specific universes (e.g. Mirror of a scala.reflect.api.JavaUniverse is capable of reflection).

Definition Classes
Mirrors
abstract type Modifiers >: Null <: ModifiersApi
The type of tree modifiers (not a tree, but rather part of DefTrees).
The type of tree modifiers (not a tree, but rather part of DefTrees).

Definition Classes
Trees
abstract type Name >: Null <: NameApi
The abstract type of names.
The abstract type of names.

Definition Classes
Names
abstract type Position >: Null <: api.Position { type Pos = Universe.this.Position }
Defines a universe-specific notion of positions.
Defines a universe-specific notion of positions. The main documentation entry about positions is located at scala.reflect.api.Position.

Definition Classes
Positions
abstract type RuntimeClass >: Null <: AnyRef
Abstracts the runtime representation of a class on the underlying platform.
Abstracts the runtime representation of a class on the underlying platform.

Definition Classes
Mirrors
abstract type TermName >: Null <: TermNameApi with Name
The abstract type of names representing types.
The abstract type of names representing types.

Definition Classes
Names
abstract type TypeName >: Null <: TypeNameApi with Name
The abstract type of names representing terms.
The abstract type of names representing terms.

Definition Classes
Names
abstract type ArrayArgument >: Null <: Universe.ArrayArgumentApi with Universe.JavaArgument
An array argument to a Java annotation as in @Target(value={TYPE,FIELD,METHOD,PARAMETER})
An array argument to a Java annotation as in @Target(value={TYPE,FIELD,METHOD,PARAMETER})

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

Definition Classes
Annotations
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use Annotation.tree to inspect annotation arguments
abstract class ArrayArgumentExtractor extends AnyRef
An extractor class to create and pattern match with syntax ArrayArgument(args) 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
abstract type JavaArgument >: Null <: Universe.JavaArgumentApi
A Java annotation argument
A Java annotation argument

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

Definition Classes
Annotations
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use Annotation.tree to inspect annotation arguments
abstract type LiteralArgument >: Null <: Universe.LiteralArgumentApi with Universe.JavaArgument
A literal argument to a Java annotation as "use X instead" in @Deprecated("use X instead")
A literal argument to a Java annotation as "use X instead" in @Deprecated("use X instead")

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

Definition Classes
Annotations
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use Annotation.tree to inspect annotation arguments
abstract class LiteralArgumentExtractor extends AnyRef
An extractor class to create and pattern match with syntax LiteralArgument(value) 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
abstract type NestedArgument >: Null <: Universe.NestedArgumentApi with Universe.JavaArgument
A nested annotation argument to a Java annotation as @Nested in @Outer(@Nested).
A nested annotation argument to a Java annotation as @Nested in @Outer(@Nested).

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

Definition Classes
Annotations
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use Annotation.tree to inspect annotation arguments
abstract class NestedArgumentExtractor extends AnyRef
An extractor class to create and pattern match with syntax NestedArgument(annotation) 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
type BuildApi = ReificationSupportApi

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

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

Abstract Value Members

abstract val Alternative: AlternativeExtractor
The constructor/extractor for Alternative instances.
The constructor/extractor for Alternative instances.

Definition Classes
Trees

implicit abstract val AlternativeTag: ClassTag[Alternative]

Definition Classes
ImplicitTags

abstract val Annotated: AnnotatedExtractor
The constructor/extractor for Annotated instances.
The constructor/extractor for Annotated instances.

Definition Classes
Trees

implicit abstract val AnnotatedTag: ClassTag[Annotated]

Definition Classes
ImplicitTags

abstract val AnnotatedType: AnnotatedTypeExtractor
The constructor/extractor for AnnotatedType instances.
The constructor/extractor for AnnotatedType instances.

Definition Classes
Types

implicit abstract val AnnotatedTypeTag: ClassTag[AnnotatedType]

Definition Classes
ImplicitTags

abstract val Annotation: AnnotationExtractor
The constructor/extractor for Annotation instances.
The constructor/extractor for Annotation instances.

Definition Classes
Annotations

implicit abstract val AnnotationTag: ClassTag[Annotation]

Definition Classes
ImplicitTags

abstract val AppliedTypeTree: AppliedTypeTreeExtractor
The constructor/extractor for AppliedTypeTree instances.
The constructor/extractor for AppliedTypeTree instances.

Definition Classes
Trees

implicit abstract val AppliedTypeTreeTag: ClassTag[AppliedTypeTree]

Definition Classes
ImplicitTags

abstract val Apply: ApplyExtractor
The constructor/extractor for Apply instances.
The constructor/extractor for Apply instances.

Definition Classes
Trees

implicit abstract val ApplyTag: ClassTag[Apply]

Definition Classes
ImplicitTags

implicit abstract val ArrayArgumentTag: ClassTag[ArrayArgument]

Definition Classes
ImplicitTags

abstract val Assign: AssignExtractor
The constructor/extractor for Assign instances.
The constructor/extractor for Assign instances.

Definition Classes
Trees

abstract val AssignOrNamedArg: AssignOrNamedArgExtractor
The constructor/extractor for AssignOrNamedArg instances.
The constructor/extractor for AssignOrNamedArg instances.

Definition Classes
Trees

implicit abstract val AssignOrNamedArgTag: ClassTag[AssignOrNamedArg]

Definition Classes
ImplicitTags

implicit abstract val AssignTag: ClassTag[Assign]

Definition Classes
ImplicitTags

abstract val Bind: BindExtractor
The constructor/extractor for Bind instances.
The constructor/extractor for Bind instances.

Definition Classes
Trees

implicit abstract val BindTag: ClassTag[Bind]

Definition Classes
ImplicitTags

abstract val Block: BlockExtractor
The constructor/extractor for Block instances.
The constructor/extractor for Block instances.

Definition Classes
Trees

implicit abstract val BlockTag: ClassTag[Block]

Definition Classes
ImplicitTags

abstract val BoundedWildcardType: BoundedWildcardTypeExtractor
The constructor/extractor for BoundedWildcardType instances.
The constructor/extractor for BoundedWildcardType instances.

Definition Classes
Types

implicit abstract val BoundedWildcardTypeTag: ClassTag[BoundedWildcardType]

Definition Classes
ImplicitTags

abstract val CaseDef: CaseDefExtractor
The constructor/extractor for CaseDef instances.
The constructor/extractor for CaseDef instances.

Definition Classes
Trees

implicit abstract val CaseDefTag: ClassTag[CaseDef]

Definition Classes
ImplicitTags

abstract val ClassDef: ClassDefExtractor
The constructor/extractor for ClassDef instances.
The constructor/extractor for ClassDef instances.

Definition Classes
Trees

implicit abstract val ClassDefTag: ClassTag[ClassDef]

Definition Classes
ImplicitTags

abstract val ClassInfoType: ClassInfoTypeExtractor
The constructor/extractor for ClassInfoType instances.
The constructor/extractor for ClassInfoType instances.

Definition Classes
Types

implicit abstract val ClassInfoTypeTag: ClassTag[ClassInfoType]

Definition Classes
ImplicitTags

implicit abstract val ClassSymbolTag: ClassTag[ClassSymbol]

Definition Classes
ImplicitTags

implicit abstract val CompoundTypeTag: ClassTag[CompoundType]

Definition Classes
ImplicitTags

abstract val CompoundTypeTree: CompoundTypeTreeExtractor
The constructor/extractor for CompoundTypeTree instances.
The constructor/extractor for CompoundTypeTree instances.

Definition Classes
Trees

implicit abstract val CompoundTypeTreeTag: ClassTag[CompoundTypeTree]

Definition Classes
ImplicitTags

abstract val Constant: ConstantExtractor
The constructor/extractor for Constant instances.
The constructor/extractor for Constant instances.

Definition Classes
Constants

implicit abstract val ConstantTag: ClassTag[Constant]

Definition Classes
ImplicitTags

abstract val ConstantType: ConstantTypeExtractor
The constructor/extractor for ConstantType instances.
The constructor/extractor for ConstantType instances.

Definition Classes
Types

implicit abstract val ConstantTypeTag: ClassTag[ConstantType]

Definition Classes
ImplicitTags

abstract val DefDef: DefDefExtractor
The constructor/extractor for DefDef instances.
The constructor/extractor for DefDef instances.

Definition Classes
Trees

implicit abstract val DefDefTag: ClassTag[DefDef]

Definition Classes
ImplicitTags

implicit abstract val DefTreeTag: ClassTag[DefTree]

Definition Classes
ImplicitTags

abstract val EmptyTree: Tree
The empty tree
The empty tree

Definition Classes
Trees

abstract val ExistentialType: ExistentialTypeExtractor
The constructor/extractor for ExistentialType instances.
The constructor/extractor for ExistentialType instances.

Definition Classes
Types

implicit abstract val ExistentialTypeTag: ClassTag[ExistentialType]

Definition Classes
ImplicitTags

abstract val ExistentialTypeTree: ExistentialTypeTreeExtractor
The constructor/extractor for ExistentialTypeTree instances.
The constructor/extractor for ExistentialTypeTree instances.

Definition Classes
Trees

implicit abstract val ExistentialTypeTreeTag: ClassTag[ExistentialTypeTree]

Definition Classes
ImplicitTags

abstract val Flag: FlagValues
A module that contains all possible values that can constitute flag sets.
A module that contains all possible values that can constitute flag sets.

Definition Classes
FlagSets

implicit abstract val FlagSetTag: ClassTag[FlagSet]

Definition Classes
ImplicitTags

implicit abstract val FreeTermSymbolTag: ClassTag[FreeTermSymbol]
Tag that preserves the identity of FreeTermSymbol in the face of erasure.
Tag that preserves the identity of FreeTermSymbol in the face of erasure. Can be used for pattern matching, instance tests, serialization and the like.

Definition Classes
Internals

implicit abstract val FreeTypeSymbolTag: ClassTag[FreeTypeSymbol]
Tag that preserves the identity of FreeTermSymbol in the face of erasure.
Tag that preserves the identity of FreeTermSymbol in the face of erasure. Can be used for pattern matching, instance tests, serialization and the like.

Definition Classes
Internals

abstract val Function: FunctionExtractor
The constructor/extractor for Function instances.
The constructor/extractor for Function instances.

Definition Classes
Trees

implicit abstract val FunctionTag: ClassTag[Function]

Definition Classes
ImplicitTags

implicit abstract val GenericApplyTag: ClassTag[GenericApply]

Definition Classes
ImplicitTags

abstract def Ident(sym: Symbol): Ident
A factory method for Ident nodes.
A factory method for Ident nodes.

Definition Classes
Trees

abstract val Ident: IdentExtractor
The constructor/extractor for Ident instances.
The constructor/extractor for Ident instances.

Definition Classes
Trees

implicit abstract val IdentTag: ClassTag[Ident]

Definition Classes
ImplicitTags

abstract val If: IfExtractor
The constructor/extractor for If instances.
The constructor/extractor for If instances.

Definition Classes
Trees

implicit abstract val IfTag: ClassTag[If]

Definition Classes
ImplicitTags

implicit abstract val ImplDefTag: ClassTag[ImplDef]

Definition Classes
ImplicitTags

abstract val Import: ImportExtractor
The constructor/extractor for Import instances.
The constructor/extractor for Import instances.

Definition Classes
Trees

abstract val ImportSelector: ImportSelectorExtractor
The constructor/extractor for ImportSelector instances.
The constructor/extractor for ImportSelector instances.

Definition Classes
Trees

implicit abstract val ImportSelectorTag: ClassTag[ImportSelector]

Definition Classes
ImplicitTags

implicit abstract val ImportTag: ClassTag[Import]

Definition Classes
ImplicitTags

implicit abstract val JavaArgumentTag: ClassTag[JavaArgument]

Definition Classes
ImplicitTags

abstract val LabelDef: LabelDefExtractor
The constructor/extractor for LabelDef instances.
The constructor/extractor for LabelDef instances.

Definition Classes
Trees

implicit abstract val LabelDefTag: ClassTag[LabelDef]

Definition Classes
ImplicitTags

abstract val Literal: LiteralExtractor
The constructor/extractor for Literal instances.
The constructor/extractor for Literal instances.

Definition Classes
Trees

implicit abstract val LiteralArgumentTag: ClassTag[LiteralArgument]

Definition Classes
ImplicitTags

implicit abstract val LiteralTag: ClassTag[Literal]

Definition Classes
ImplicitTags

abstract val Match: MatchExtractor
The constructor/extractor for Match instances.
The constructor/extractor for Match instances.

Definition Classes
Trees

implicit abstract val MatchTag: ClassTag[Match]

Definition Classes
ImplicitTags

implicit abstract val MemberDefTag: ClassTag[MemberDef]

Definition Classes
ImplicitTags

implicit abstract val MemberScopeTag: ClassTag[MemberScope]

Definition Classes
ImplicitTags

implicit abstract val MethodSymbolTag: ClassTag[MethodSymbol]

Definition Classes
ImplicitTags

abstract val MethodType: MethodTypeExtractor
The constructor/extractor for MethodType instances.
The constructor/extractor for MethodType instances.

Definition Classes
Types

implicit abstract val MethodTypeTag: ClassTag[MethodType]

Definition Classes
ImplicitTags

implicit abstract val MirrorTag: ClassTag[Mirror]

Definition Classes
ImplicitTags

abstract val Modifiers: ModifiersExtractor
The constructor/extractor for Modifiers instances.
The constructor/extractor for Modifiers instances.

Definition Classes
Trees

implicit abstract val ModifiersTag: ClassTag[Modifiers]

Definition Classes
ImplicitTags

abstract val ModuleDef: ModuleDefExtractor
The constructor/extractor for ModuleDef instances.
The constructor/extractor for ModuleDef instances.

Definition Classes
Trees

implicit abstract val ModuleDefTag: ClassTag[ModuleDef]

Definition Classes
ImplicitTags

implicit abstract val ModuleSymbolTag: ClassTag[ModuleSymbol]

Definition Classes
ImplicitTags

implicit abstract val NameTag: ClassTag[Name]

Definition Classes
ImplicitTags

implicit abstract val NameTreeTag: ClassTag[NameTree]

Definition Classes
ImplicitTags

implicit abstract val NestedArgumentTag: ClassTag[NestedArgument]

Definition Classes
ImplicitTags

abstract val New: NewExtractor
The constructor/extractor for New instances.
The constructor/extractor for New instances.

Definition Classes
Trees

implicit abstract val NewTag: ClassTag[New]

Definition Classes
ImplicitTags

abstract val NoFlags: FlagSet
The empty set of flags
The empty set of flags

Definition Classes
FlagSets

abstract val NoPosition: Position
A special "missing" position.
A special "missing" position.

Definition Classes
Positions

abstract val NoPrefix: Type
This constant is used as a special value denoting the empty prefix in a path dependent type.
This constant is used as a special value denoting the empty prefix in a path dependent type. For instance x.type is represented as SingleType(NoPrefix, <x>), where <x> stands for the symbol for x.

Definition Classes
Types

abstract val NoSymbol: Symbol
A special "missing" symbol.
A special "missing" symbol. Commonly used in the API to denote a default or empty value.

Definition Classes
Symbols

abstract val NoType: Type
This constant is used as a special value that indicates that no meaningful type exists.
This constant is used as a special value that indicates that no meaningful type exists.

Definition Classes
Types

abstract val NullaryMethodType: NullaryMethodTypeExtractor
The constructor/extractor for NullaryMethodType instances.
The constructor/extractor for NullaryMethodType instances.

Definition Classes
Types

implicit abstract val NullaryMethodTypeTag: ClassTag[NullaryMethodType]

Definition Classes
ImplicitTags

abstract val PackageDef: PackageDefExtractor
The constructor/extractor for PackageDef instances.
The constructor/extractor for PackageDef instances.

Definition Classes
Trees

implicit abstract val PackageDefTag: ClassTag[PackageDef]

Definition Classes
ImplicitTags

abstract val PolyType: PolyTypeExtractor
The constructor/extractor for PolyType instances.
The constructor/extractor for PolyType instances.

Definition Classes
Types

implicit abstract val PolyTypeTag: ClassTag[PolyType]

Definition Classes
ImplicitTags

implicit abstract val PositionTag: ClassTag[Position]

Definition Classes
ImplicitTags

abstract val RefTree: RefTreeExtractor
The constructor/extractor for RefTree instances.
The constructor/extractor for RefTree instances.

Definition Classes
Trees

implicit abstract val RefTreeTag: ClassTag[RefTree]

Definition Classes
ImplicitTags

abstract val ReferenceToBoxed: ReferenceToBoxedExtractor
The constructor/extractor for ReferenceToBoxed instances.
The constructor/extractor for ReferenceToBoxed instances.

Definition Classes
Internals

implicit abstract val ReferenceToBoxedTag: ClassTag[ReferenceToBoxed]
Tag that preserves the identity of ReferenceToBoxed in the face of erasure.
Tag that preserves the identity of ReferenceToBoxed in the face of erasure. Can be used for pattern matching, instance tests, serialization and the like.

Definition Classes
Internals

abstract val RefinedType: RefinedTypeExtractor
The constructor/extractor for RefinedType instances.
The constructor/extractor for RefinedType instances.

Definition Classes
Types

implicit abstract val RefinedTypeTag: ClassTag[RefinedType]

Definition Classes
ImplicitTags

abstract val Return: ReturnExtractor
The constructor/extractor for Return instances.
The constructor/extractor for Return instances.

Definition Classes
Trees

implicit abstract val ReturnTag: ClassTag[Return]

Definition Classes
ImplicitTags

implicit abstract val RuntimeClassTag: ClassTag[RuntimeClass]

Definition Classes
ImplicitTags

implicit abstract val ScopeTag: ClassTag[Scope]

Definition Classes
ImplicitTags

abstract def Select(qualifier: Tree, sym: Symbol): Select
A factory method for Select nodes.
A factory method for Select nodes.

Definition Classes
Trees

abstract val Select: SelectExtractor
The constructor/extractor for Select instances.
The constructor/extractor for Select instances.

Definition Classes
Trees

abstract val SelectFromTypeTree: SelectFromTypeTreeExtractor
The constructor/extractor for SelectFromTypeTree instances.
The constructor/extractor for SelectFromTypeTree instances.

Definition Classes
Trees

implicit abstract val SelectFromTypeTreeTag: ClassTag[SelectFromTypeTree]

Definition Classes
ImplicitTags

implicit abstract val SelectTag: ClassTag[Select]

Definition Classes
ImplicitTags

abstract val SingleType: SingleTypeExtractor
The constructor/extractor for SingleType instances.
The constructor/extractor for SingleType instances.

Definition Classes
Types

implicit abstract val SingleTypeTag: ClassTag[SingleType]

Definition Classes
ImplicitTags

implicit abstract val SingletonTypeTag: ClassTag[SingletonType]

Definition Classes
ImplicitTags

abstract val SingletonTypeTree: SingletonTypeTreeExtractor
The constructor/extractor for SingletonTypeTree instances.
The constructor/extractor for SingletonTypeTree instances.

Definition Classes
Trees

implicit abstract val SingletonTypeTreeTag: ClassTag[SingletonTypeTree]

Definition Classes
ImplicitTags

abstract val Star: StarExtractor
The constructor/extractor for Star instances.
The constructor/extractor for Star instances.

Definition Classes
Trees

implicit abstract val StarTag: ClassTag[Star]

Definition Classes
ImplicitTags

abstract val Super: SuperExtractor
The constructor/extractor for Super instances.
The constructor/extractor for Super instances.

Definition Classes
Trees

implicit abstract val SuperTag: ClassTag[Super]

Definition Classes
ImplicitTags

abstract val SuperType: SuperTypeExtractor
The constructor/extractor for SuperType instances.
The constructor/extractor for SuperType instances.

Definition Classes
Types

implicit abstract val SuperTypeTag: ClassTag[SuperType]

Definition Classes
ImplicitTags

implicit abstract val SymTreeTag: ClassTag[SymTree]

Definition Classes
ImplicitTags

implicit abstract val SymbolTag: ClassTag[Symbol]

Definition Classes
ImplicitTags

abstract val Template: TemplateExtractor
The constructor/extractor for Template instances.
The constructor/extractor for Template instances.

Definition Classes
Trees

implicit abstract val TemplateTag: ClassTag[Template]

Definition Classes
ImplicitTags

abstract val TermName: TermNameExtractor
The constructor/extractor for TermName instances.
The constructor/extractor for TermName instances.

Definition Classes
Names

implicit abstract val TermNameTag: ClassTag[TermName]

Definition Classes
ImplicitTags

implicit abstract val TermSymbolTag: ClassTag[TermSymbol]

Definition Classes
ImplicitTags

implicit abstract val TermTreeTag: ClassTag[TermTree]

Definition Classes
ImplicitTags

abstract def This(sym: Symbol): Tree
A factory method for This nodes.
A factory method for This nodes.

Definition Classes
Trees

abstract val This: ThisExtractor
The constructor/extractor for This instances.
The constructor/extractor for This instances.

Definition Classes
Trees

implicit abstract val ThisTag: ClassTag[This]

Definition Classes
ImplicitTags

abstract val ThisType: ThisTypeExtractor
The constructor/extractor for ThisType instances.
The constructor/extractor for ThisType instances.

Definition Classes
Types

implicit abstract val ThisTypeTag: ClassTag[ThisType]

Definition Classes
ImplicitTags

abstract val Throw: ThrowExtractor
The constructor/extractor for Throw instances.
The constructor/extractor for Throw instances.

Definition Classes
Trees

implicit abstract val ThrowTag: ClassTag[Throw]

Definition Classes
ImplicitTags

implicit abstract val TreeCopierTag: ClassTag[TreeCopier]

Definition Classes
ImplicitTags

implicit abstract val TreeTag: ClassTag[Tree]

Definition Classes
ImplicitTags

abstract val Try: TryExtractor
The constructor/extractor for Try instances.
The constructor/extractor for Try instances.

Definition Classes
Trees

implicit abstract val TryTag: ClassTag[Try]

Definition Classes
ImplicitTags

implicit abstract val TypTreeTag: ClassTag[TypTree]

Definition Classes
ImplicitTags

abstract val TypeApply: TypeApplyExtractor
The constructor/extractor for TypeApply instances.
The constructor/extractor for TypeApply instances.

Definition Classes
Trees

implicit abstract val TypeApplyTag: ClassTag[TypeApply]

Definition Classes
ImplicitTags

abstract val TypeBounds: TypeBoundsExtractor
The constructor/extractor for TypeBounds instances.
The constructor/extractor for TypeBounds instances.

Definition Classes
Types

implicit abstract val TypeBoundsTag: ClassTag[TypeBounds]

Definition Classes
ImplicitTags

abstract val TypeBoundsTree: TypeBoundsTreeExtractor
The constructor/extractor for TypeBoundsTree instances.
The constructor/extractor for TypeBoundsTree instances.

Definition Classes
Trees

implicit abstract val TypeBoundsTreeTag: ClassTag[TypeBoundsTree]

Definition Classes
ImplicitTags

abstract val TypeDef: TypeDefExtractor
The constructor/extractor for TypeDef instances.
The constructor/extractor for TypeDef instances.

Definition Classes
Trees

implicit abstract val TypeDefTag: ClassTag[TypeDef]

Definition Classes
ImplicitTags

abstract val TypeName: TypeNameExtractor
The constructor/extractor for TypeName instances.
The constructor/extractor for TypeName instances.

Definition Classes
Names

implicit abstract val TypeNameTag: ClassTag[TypeName]

Definition Classes
ImplicitTags

abstract val TypeRef: TypeRefExtractor
The constructor/extractor for TypeRef instances.
The constructor/extractor for TypeRef instances.

Definition Classes
Types

implicit abstract val TypeRefTag: ClassTag[TypeRef]

Definition Classes
ImplicitTags

implicit abstract val TypeSymbolTag: ClassTag[TypeSymbol]

Definition Classes
ImplicitTags

implicit abstract val TypeTagg: ClassTag[Type]

Definition Classes
ImplicitTags

abstract def TypeTree(tp: Type): TypeTree
A factory method for TypeTree nodes.
A factory method for TypeTree nodes.

Definition Classes
Trees

abstract val TypeTree: TypeTreeExtractor
The constructor/extractor for TypeTree instances.
The constructor/extractor for TypeTree instances.

Definition Classes
Trees

implicit abstract val TypeTreeTag: ClassTag[TypeTree]

Definition Classes
ImplicitTags

abstract val Typed: TypedExtractor
The constructor/extractor for Typed instances.
The constructor/extractor for Typed instances.

Definition Classes
Trees

implicit abstract val TypedTag: ClassTag[Typed]

Definition Classes
ImplicitTags

abstract val UnApply: UnApplyExtractor
The constructor/extractor for UnApply instances.
The constructor/extractor for UnApply instances.

Definition Classes
Trees

implicit abstract val UnApplyTag: ClassTag[UnApply]

Definition Classes
ImplicitTags

abstract val ValDef: ValDefExtractor
The constructor/extractor for ValDef instances.
The constructor/extractor for ValDef instances.

Definition Classes
Trees

implicit abstract val ValDefTag: ClassTag[ValDef]

Definition Classes
ImplicitTags

implicit abstract val ValOrDefDefTag: ClassTag[ValOrDefDef]

Definition Classes
ImplicitTags

abstract val WildcardType: Type
An object representing an unknown type, used during type inference.
An object representing an unknown type, used during type inference. If you see WildcardType outside of inference it is almost certainly a bug.

Definition Classes
Types

implicit abstract def addFlagOps(left: FlagSet): FlagOps
The API of FlagSet instances.
The API of FlagSet instances.

Definition Classes
FlagSets

abstract def annotationToTree(ann: Annotation): Tree

Attributes
protected[scala]
Definition Classes
Annotations

abstract def appliedType(sym: Symbol, args: Type*): Type

Definition Classes
Types
See also
appliedType

abstract def appliedType(sym: Symbol, args: List[Type]): Type

Definition Classes
Types
See also
appliedType

abstract def appliedType(tycon: Type, args: Type*): Type

Definition Classes
Types
See also
appliedType

abstract def appliedType(tycon: Type, args: List[Type]): Type
A creator for type applications
A creator for type applications

Definition Classes
Types

abstract def atPos[T <: Tree](pos: Position)(tree: T): T
Assigns a given position to all position-less nodes of a given AST.
Assigns a given position to all position-less nodes of a given AST.

Definition Classes
Positions

abstract val compat: Compat
Provides enrichments to ensure source compatibility between Scala 2.10 and Scala 2.11.
Provides enrichments to ensure source compatibility between Scala 2.10 and Scala 2.11. If in your reflective program for Scala 2.10 you've used something that's now become an internal API, a single compat._ import will fix things for you.

Definition Classes
Internals

abstract val definitions: DefinitionsApi
A value containing all standard definitions in DefinitionsApi
A value containing all standard definitions in DefinitionsApi

Definition Classes
StandardDefinitions

abstract def glb(ts: List[Type]): Type
The greatest lower bound of a list of types, as determined by <:<.
The greatest lower bound of a list of types, as determined by <:<.

Definition Classes
Types

abstract val internal: Internal

Definition Classes
Internals
See also
InternalApi

abstract def lub(xs: List[Type]): Type
The least upper bound of a list of types, as determined by <:<.
The least upper bound of a list of types, as determined by <:<.

Definition Classes
Types

abstract def newCodePrinter(out: PrintWriter, tree: Tree, printRootPkg: Boolean): TreePrinter
Hook to define what showCode(...) means.
Hook to define what showCode(...) means.

Attributes
protected
Definition Classes
Printers

abstract def newLazyTreeCopier: TreeCopier
Creates a lazy tree copier.
Creates a lazy tree copier.

Definition Classes
Trees

abstract def newRawTreePrinter(out: PrintWriter): TreePrinter
Hook to define what showRaw(...) means.
Hook to define what showRaw(...) means.

Attributes
protected
Definition Classes
Printers

abstract def newStrictTreeCopier: TreeCopier
Creates a strict tree copier.
Creates a strict tree copier.

Definition Classes
Trees

abstract def newTreePrinter(out: PrintWriter): TreePrinter
Hook to define what show(...) means.
Hook to define what show(...) means.

Attributes
protected
Definition Classes
Printers

abstract val noSelfType: ValDef
An empty deferred value definition corresponding to: val _: _ This is used as a placeholder in the self parameter Template if there is no definition of a self value of self type.
An empty deferred value definition corresponding to: val _: _ This is used as a placeholder in the self parameter Template if there is no definition of a self value of self type.

Definition Classes
Trees

abstract val pendingSuperCall: Apply
An empty superclass constructor call corresponding to: super.<init>() This is used as a placeholder in the primary constructor body in class templates to denote the insertion point of a call to superclass constructor after the typechecker figures out the superclass of a given template.
An empty superclass constructor call corresponding to: super.<init>() This is used as a placeholder in the primary constructor body in class templates to denote the insertion point of a call to superclass constructor after the typechecker figures out the superclass of a given template.

Definition Classes
Trees

abstract val rootMirror: Mirror
The root mirror of this universe.
The root mirror of this universe. This mirror contains standard Scala classes and types such as Any, AnyRef, AnyVal, Nothing, Null, and all classes loaded from scala-library, which are shared across all mirrors within the enclosing universe.

Definition Classes
Mirrors

abstract def show(position: Position): String
Renders a prettified representation of a position.
Renders a prettified representation of a position.

Definition Classes
Printers

abstract def show(flags: FlagSet): String
Renders a prettified representation of a flag set.
Renders a prettified representation of a flag set.

Definition Classes
Printers

abstract def show(name: Name): String
Renders a prettified representation of a name.
Renders a prettified representation of a name.

Definition Classes
Printers

abstract def showDecl(sym: Symbol): String
Renders a string that represents a declaration of this symbol written in Scala.
Renders a string that represents a declaration of this symbol written in Scala.

Definition Classes
Printers

abstract def symbolOf[T](implicit arg0: WeakTypeTag[T]): TypeSymbol
Type symbol of x as derived from a type tag.
Type symbol of x as derived from a type tag.

Definition Classes
TypeTags

abstract val termNames: TermNamesApi
A value containing all standard term names.
A value containing all standard term names.

Definition Classes
StandardNames

abstract def treeToAnnotation(tree: Tree): Annotation

Attributes
protected[scala]
Definition Classes
Annotations

abstract val typeNames: TypeNamesApi
A value containing all standard type names.
A value containing all standard type names.

Definition Classes
StandardNames

abstract def wrappingPos(trees: List[Tree]): Position
A position that wraps the non-empty set of trees.
A position that wraps the non-empty set of trees. The point of the wrapping position is the point of the first trees' position. If all some the trees are non-synthetic, returns a range position enclosing the non-synthetic trees Otherwise returns a synthetic offset position to point.

Definition Classes
Positions

abstract def wrappingPos(default: Position, trees: List[Tree]): Position
A position that wraps a set of trees.
A position that wraps a set of trees. The point of the wrapping position is the point of the default position. If some of the trees are ranges, returns a range position enclosing all ranges Otherwise returns default position.

Definition Classes
Positions

abstract def Apply(sym: Symbol, args: Tree*): Tree
A factory method for Apply nodes.
A factory method for Apply nodes.

Definition Classes
Trees
Annotations
@deprecated
Deprecated
(Since version 2.10.1) use q"$sym(..$args)" instead

abstract def ApplyConstructor(tpt: Tree, args: List[Tree]): Tree
0-1 argument list new, based on a type tree.
0-1 argument list new, based on a type tree.

Definition Classes
Trees
Annotations
@deprecated
Deprecated
(Since version 2.10.1) use q"new $tpt(..$args)" instead

abstract val ArrayArgument: ArrayArgumentExtractor
The constructor/extractor for ArrayArgument instances.
The constructor/extractor for ArrayArgument instances.

Definition Classes
Annotations
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use Annotation.tree to inspect annotation arguments

abstract def Bind(sym: Symbol, body: Tree): Bind
A factory method for Bind nodes.
A factory method for Bind nodes.

Definition Classes
Trees
Annotations
@deprecated
Deprecated
(Since version 2.10.1) use the canonical Bind constructor to create a bind and then initialize its symbol manually

abstract def Block(stats: Tree*): Block
A factory method for Block nodes.
A factory method for Block nodes. Flattens directly nested blocks.

Definition Classes
Trees
Annotations
@deprecated
Deprecated
(Since version 2.10.1) use q"{..$stats}" instead. Flatten directly nested blocks manually if needed

abstract def CaseDef(pat: Tree, body: Tree): CaseDef
A factory method for CaseDef nodes.
A factory method for CaseDef nodes.

Definition Classes
Trees
Annotations
@deprecated
Deprecated
(Since version 2.10.1) use cq"$pat => $body" instead

abstract def Ident(name: String): Ident
A factory method for Ident nodes.
A factory method for Ident nodes.

Definition Classes
Trees
Annotations
@deprecated
Deprecated
(Since version 2.10.1) use Ident(TermName(name)) instead

abstract val LiteralArgument: LiteralArgumentExtractor
The constructor/extractor for LiteralArgument instances.
The constructor/extractor for LiteralArgument instances.

Definition Classes
Annotations
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use Annotation.tree to inspect annotation arguments

abstract val NestedArgument: NestedArgumentExtractor
The constructor/extractor for NestedArgument instances.
The constructor/extractor for NestedArgument instances.

Definition Classes
Annotations
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use Annotation.tree to inspect annotation arguments

abstract def New(sym: Symbol, args: Tree*): Tree
0-1 argument list new, based on a symbol.
0-1 argument list new, based on a symbol.

Definition Classes
Trees
Annotations
@deprecated
Deprecated
(Since version 2.10.1) use q"new ${sym.toType}(..$args)" instead

abstract def New(tpe: Type, args: Tree*): Tree
0-1 argument list new, based on a type.
0-1 argument list new, based on a type.

Definition Classes
Trees
Annotations
@deprecated
Deprecated
(Since version 2.10.1) use q"new $tpe(..$args)" instead

abstract def New(tpt: Tree, argss: List[List[Tree]]): Tree
Factory method for object creation new tpt(args_1)...(args_n) 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
Annotations
@deprecated
Deprecated
(Since version 2.10.1) use q"new $tpt(...$argss)" instead

abstract def Select(qualifier: Tree, name: String): Select
A factory method for Select nodes.
A factory method for Select nodes. The string name argument is assumed to represent a TermName.

Definition Classes
Trees
Annotations
@deprecated
Deprecated
(Since version 2.10.1) use Select(tree, TermName(name)) instead

abstract def Super(sym: Symbol, mix: TypeName): Tree
A factory method for Super nodes.
A factory method for Super nodes.

Definition Classes
Trees
Annotations
@deprecated
Deprecated
(Since version 2.10.1) use q"$sym.super[$mix].x".qualifier instead

abstract def Throw(tpe: Type, args: Tree*): Throw
A factory method for Throw nodes.
A factory method for Throw nodes.

Definition Classes
Trees
Annotations
@deprecated
Deprecated
(Since version 2.10.1) use q"throw new $tpe(..$args)" instead

abstract def Try(body: Tree, cases: (Tree, Tree)*): Try
A factory method for Try nodes.
A factory method for Try nodes.

Definition Classes
Trees
Annotations
@deprecated
Deprecated
(Since version 2.10.1) convert cases into casedefs and use q"try $body catch { case ..$newcases }" instead

abstract val build: ReificationSupportApi

Definition Classes
Internals
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use internal.reificationSupport instead

abstract val emptyValDef: ValDef

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

abstract def newTermName(s: String): TermName
Create a new term name.
Create a new term name.

Definition Classes
Names
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use TermName instead

abstract def newTypeName(s: String): TypeName
Creates a new type name.
Creates a new type name.

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

abstract val nme: TermNamesApi

Definition Classes
StandardNames
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use termNames instead
See also
termNames

abstract val tpnme: TypeNamesApi

Definition Classes
StandardNames
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use typeNames instead
See also
typeNames

Concrete Value Members

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

Definition Classes
Exprs

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 Universe to any2stringadd[Universe] performed by method any2stringadd in scala.Predef.
Definition Classes
any2stringadd

def ->[B](y: B): (Universe, B)

Implicit
This member is added by an implicit conversion from Universe to ArrowAssoc[Universe] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
Annotations
@inline()

final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any

def Modifiers(flags: FlagSet): Modifiers
The factory for Modifiers instances.
The factory for Modifiers instances.

Definition Classes
Trees

def Modifiers(flags: FlagSet, privateWithin: Name): Modifiers
The factory for Modifiers instances.
The factory for Modifiers instances.

Definition Classes
Trees

lazy val NoMods: Modifiers
An empty Modifiers object: no flags, empty visibility annotation and no Scala annotations.
An empty Modifiers object: no flags, empty visibility annotation and no Scala annotations.

Definition Classes
Trees

final def asInstanceOf[T0]: T0

Definition Classes
Any

def clone(): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()

def ensuring(cond: (Universe) ⇒ Boolean, msg: ⇒ Any): Universe

Implicit
This member is added by an implicit conversion from Universe to Ensuring[Universe] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring

def ensuring(cond: (Universe) ⇒ Boolean): Universe

Implicit
This member is added by an implicit conversion from Universe to Ensuring[Universe] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring

def ensuring(cond: Boolean, msg: ⇒ Any): Universe

Implicit
This member is added by an implicit conversion from Universe to Ensuring[Universe] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring

def ensuring(cond: Boolean): Universe

Implicit
This member is added by an implicit conversion from Universe to Ensuring[Universe] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring

final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef

def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any

def finalize(): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )

final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@native()

def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@native()

final def isInstanceOf[T0]: Boolean

Definition Classes
Any

def itransform(transformer: Transformer, tree: Tree): Tree
Delegates the transformation strategy to scala.reflect.internal.Trees, because pattern matching on abstract types we have here degrades performance.
Delegates the transformation strategy to scala.reflect.internal.Trees, because pattern matching on abstract types we have here degrades performance.

Attributes
protected
Definition Classes
Trees

def itraverse(traverser: Traverser, tree: Tree): Unit
Delegates the traversal strategy to scala.reflect.internal.Trees, because pattern matching on abstract types we have here degrades performance.
Delegates the traversal strategy to scala.reflect.internal.Trees, because pattern matching on abstract types we have here degrades performance.

Attributes
protected
Definition Classes
Trees

final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef

final def notify(): Unit

Definition Classes
AnyRef
Annotations
@native()

final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@native()

macro def reify[T](expr: T): Expr[T]
Use reify to produce the abstract syntax tree representing a given Scala expression.
Use reify to produce the abstract syntax tree representing a given Scala expression.
For example:
val five = reify{ 5 } // Literal(Constant(5)) reify{ 5.toString } // Apply(Select(Literal(Constant(5)), TermName("toString")), List()) reify{ five.splice.toString } // Apply(Select(five, TermName("toString")), List())
The produced tree is path dependent on the Universe reify was called from.
Use scala.reflect.api.Exprs#Expr.splice to embed an existing expression into a reify call. Use Expr to turn a Tree into an expression that can be spliced.

def render(what: Any, mkPrinter: (PrintWriter) ⇒ TreePrinter, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printOwners: BooleanFlag = None, printKinds: BooleanFlag = None, printMirrors: BooleanFlag = None, printPositions: BooleanFlag = None): String

Attributes
protected
Definition Classes
Printers

def show(any: Any, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printOwners: BooleanFlag = None, printKinds: BooleanFlag = None, printMirrors: BooleanFlag = None, printPositions: BooleanFlag = None): String
Renders a representation of a reflection artifact as desugared Scala code.
Renders a representation of a reflection artifact as desugared Scala code.

Definition Classes
Printers

def showCode(tree: Tree, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printOwners: BooleanFlag = None, printPositions: BooleanFlag = None, printRootPkg: Boolean = false): String
Renders the code of the passed tree, so that: 1) it can be later compiled by scalac retaining the same meaning, 2) it looks pretty.
Renders the code of the passed tree, so that: 1) it can be later compiled by scalac retaining the same meaning, 2) it looks pretty. #1 is available for unattributed trees and attributed trees #2 is more or less okay indentation-wise, but at the moment there's a lot of desugaring left in place, and that's what we plan to improve in the future. printTypes, printIds, printPositions options have the same meaning as for TreePrinter printRootPkg option is available only for attributed trees.

Definition Classes
Printers

def showRaw(position: Position): String
Renders internal structure of a position.
Renders internal structure of a position.

Definition Classes
Printers

def showRaw(flags: FlagSet): String
Renders internal structure of a flag set.
Renders internal structure of a flag set.

Definition Classes
Printers

def showRaw(name: Name): String
Renders internal structure of a name.
Renders internal structure of a name.

Definition Classes
Printers

def showRaw(any: Any, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printOwners: BooleanFlag = None, printKinds: BooleanFlag = None, printMirrors: BooleanFlag = None, printPositions: BooleanFlag = None): String
Renders internal structure of a reflection artifact as the visualization of a Scala syntax tree.
Renders internal structure of a reflection artifact as the visualization of a Scala syntax tree.

Definition Classes
Printers

final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef

def toString(): String

Definition Classes
AnyRef → Any

val treeCopy: TreeCopier
The standard (lazy) tree copier.
The standard (lazy) tree copier.

Definition Classes
Trees

def treeToString(tree: Tree): String
By default trees are printed with show
By default trees are printed with show

Attributes
protected
Definition Classes
Printers

def typeOf[T](implicit ttag: TypeTag[T]): Type
Shortcut for implicitly[TypeTag[T]].tpe
Shortcut for implicitly[TypeTag[T]].tpe

Definition Classes
TypeTags

def typeTag[T](implicit ttag: TypeTag[T]): TypeTag[T]
Shortcut for implicitly[TypeTag[T]]
Shortcut for implicitly[TypeTag[T]]

Definition Classes
TypeTags

final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... ) @native()

def weakTypeOf[T](implicit attag: WeakTypeTag[T]): Type
Shortcut for implicitly[WeakTypeTag[T]].tpe
Shortcut for implicitly[WeakTypeTag[T]].tpe

Definition Classes
TypeTags

def weakTypeTag[T](implicit attag: WeakTypeTag[T]): WeakTypeTag[T]
Shortcut for implicitly[WeakTypeTag[T]]
Shortcut for implicitly[WeakTypeTag[T]]

Definition Classes
TypeTags

def xtransform(transformer: Transformer, tree: Tree): Tree
Provides an extension hook for the transformation strategy.
Provides an extension hook for the transformation strategy. Future-proofs against new node types.

Attributes
protected
Definition Classes
Trees

def xtraverse(traverser: Traverser, tree: Tree): Unit
Provides an extension hook for the traversal strategy.
Provides an extension hook for the traversal strategy. Future-proofs against new node types.

Attributes
protected
Definition Classes
Trees

def →[B](y: B): (Universe, B)

Implicit
This member is added by an implicit conversion from Universe to ArrowAssoc[Universe] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc

Deprecated Value Members

def formatted(fmtstr: String): String

Implicit
This member is added by an implicit conversion from Universe to StringFormat[Universe] performed by method StringFormat in scala.Predef.
Definition Classes
StringFormat
Annotations
@deprecated @inline()
Deprecated
(Since version 2.12.16) Use formatString.format(value) instead of value.formatted(formatString), or use the f"" string interpolator. In Java 15 and later, formatted resolves to the new method in String which has reversed parameters.

def mkImporter(from0: Universe): Importer { val from: from0.type }

Definition Classes
Internals
Annotations
@deprecated
Deprecated
(Since version 2.11.0) use internal.createImporter instead

implicit def stringToTermName(s: String): TermName
An implicit conversion from String to TermName.
An implicit conversion from String to TermName. Enables an alternative notation "map": TermName as opposed 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 Internals

Inherited from Quasiquotes

Inherited from Liftables

Inherited from Printers

Inherited from Mirrors

Inherited from StandardLiftables

Inherited from StandardNames

Inherited from StandardDefinitions

Inherited from ImplicitTags

Inherited from TypeTags

Inherited from Exprs

Inherited from Positions

Inherited from Annotations

Inherited from Constants

Inherited from Trees

Inherited from Names

Inherited from Scopes

Inherited from FlagSets

Inherited from Types

Inherited from Symbols

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd from Universe to any2stringadd[Universe]

Inherited by implicit conversion StringFormat from Universe to StringFormat[Universe]

Inherited by implicit conversion Ensuring from Universe to Ensuring[Universe]

Inherited by implicit conversion ArrowAssoc from Universe to ArrowAssoc[Universe]

Universe

Annotations

Constants

Definitions

Expressions

Flags

Internal

Mirrors

Names

Positions

Printers

Scopes

Standard Names

Symbols

Trees

Types - Operations

TypeTags

Types

Tree Copying

Factories

Tree Traversal and Transformation

API

The methods available for each reflection entity, without the implementation. Since the reflection entities are later overridden by runtime reflection and macros, their API counterparts guarantee a minimum set of methods that are implemented.

Extractors

Extractors provide the machinery necessary to allow pattern matching and construction of reflection entities that is similar to case classes, although the entities are only abstract types that are later overridden.

Ungrouped

Packages

Universe 

Instance Constructors

Type Members

Example

Abstract Value Members

Concrete Value Members

Deprecated Value Members

Inherited from Internals

Inherited from Quasiquotes

Inherited from Liftables

Inherited from Printers

Inherited from Mirrors

Inherited from StandardLiftables

Inherited from StandardNames

Inherited from StandardDefinitions

Inherited from ImplicitTags

Inherited from TypeTags

Inherited from Exprs

Inherited from Positions

Inherited from Annotations

Inherited from Constants

Inherited from Trees

Inherited from Names

Inherited from Scopes

Inherited from FlagSets

Inherited from Types

Inherited from Symbols

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd from Universe to any2stringadd[Universe]

Inherited by implicit conversion StringFormat from Universe to StringFormat[Universe]

Inherited by implicit conversion Ensuring from Universe to Ensuring[Universe]

Inherited by implicit conversion ArrowAssoc from Universe to ArrowAssoc[Universe]

Universe

Annotations

Constants

Definitions

Expressions

Flags

Internal

Mirrors

Names

Positions

Printers

Scopes

Standard Names

Symbols

Trees

Types - Operations

TypeTags

Types

Tree Copying

Factories

Tree Traversal and Transformation

API

Extractors

Ungrouped

Universe