Scala Reflection Library2.12.21 < Back
 

# Packages

-  package root
  Definition Classes
    root
-  package scala
  Definition Classes
    root
-  package reflect
  Definition Classes
    scala
-  package macros

  EXPERIMENTAL

  EXPERIMENTAL

  The base package for Scala macros.

  Macros are functions that are called by the compiler during compilation. Within these functions the programmer has access to compiler APIs. For example, it is possible to generate, analyze and typecheck code.

  See the Macros Guide on how to get started with Scala macros.

  Definition Classes
    reflect
-  package blackbox
  Definition Classes
    macros
-  package whitebox
  Definition Classes
    macros
- Aliases
- Attachments
- Enclosures
- Evals
- ExprUtils
- FrontEnds
- Infrastructure
- Internals
- Names
- ParseException
- Parsers
- ReificationException
- Reifiers
- TypecheckException
- Typers
- UnexpectedReificationException
- Universe

c

scala.reflect.macros

# Universe 

###

#### abstract class Universe extends api.Universe

EXPERIMENTAL

The refinement of scala.reflect.api.Universe for the use by macro writers.

This universe provides mutability for reflection artifacts (e.g. macros can change types of compiler trees, add annotation to symbols representing definitions, etc) and exposes some internal compiler functionality such as `Symbol.deSkolemize` or `Tree.attachments`.

Source
  Universe.scala

Linear Supertypes
api.Universe, api.Internals, Quasiquotes, Liftables, Printers, Mirrors, StandardLiftables, StandardNames, StandardDefinitions, ImplicitTags, TypeTags, Exprs, Positions, Annotations, Constants, Trees, api.Names, Scopes, FlagSets, Types, Symbols, AnyRef, Any
 
Ordering

1. Grouped
2. Alphabetic
3. By Inheritance

Inherited

1. Universe
2. Universe
3. Internals
4. Quasiquotes
5. Liftables
6. Printers
7. Mirrors
8. StandardLiftables
9. StandardNames
10. StandardDefinitions
11. ImplicitTags
12. TypeTags
13. Exprs
14. Positions
15. Annotations
16. Constants
17. Trees
18. Names
19. Scopes
20. FlagSets
21. Types
22. Symbols
23. AnyRef
24. Any

Implicitly

1. by any2stringadd
2. by StringFormat
3. by Ensuring
4. by ArrowAssoc

1. Hide All
2. Show All

Visibility

1. Public
2. All

### Instance Constructors

1.  new Universe()

### Type Members

1.  abstract type Annotation >: Null <: Universe.AnnotationApi

   Information about an annotation.

   Information about an annotation.

   Definition Classes
     Annotations
2.  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
3.  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
4.  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:

   1. Literals of primitive value classes (`Byte`, `Short`, `Int`, `Long`, `Float`, `Double`, `Char`, `Boolean` and `Unit`) - represented directly as the corresponding type
   2. String literals - represented as instances of the `String`.
   3. References to classes, typically constructed with scala.Predef#classOf - represented as types.
   4. 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
5.  abstract class ConstantApi extends AnyRef

   The API of Constant instances.

   The API of Constant instances.

   Definition Classes
     Constants
6.  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
7.  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
8.  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
9.  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
10.  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
11.  trait CompatApi extends AnyRef

    Definition Classes
      Internals
    See also

      compat

12.  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( ... )
13.  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
14.  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
15.  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
16.  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
17.  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 `Universe`s, which is reflected by the fact that types of artifacts from different universes are not compatible. By using `Importer`s, 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 `Universe`s 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
18.  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
19.  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
20.  trait ReferenceToBoxedApi extends Universe.TermTreeApi

    The API that all references support

    The API that all references support

    Definition Classes
      Internals
21.  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
22.  trait ReificationSupportApi extends AnyRef

    This is an internal implementation class.

    This is an internal implementation class.

    Definition Classes
      Internals
23.  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

24.  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

25.  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
26.  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
27.  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
28.  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
29.  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
30.  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
31.  trait RuntimeClassApi extends AnyRef

    Has no special methods.

    Has no special methods. Is here to provides erased identity for `RuntimeClass`.

    Definition Classes
      Mirrors
32.  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
33.  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
34.  abstract class NameApi extends AnyRef

    The API of Name instances.

    The API of Name instances.

    Definition Classes
      Names
35.  trait TermNameApi extends AnyRef

    Has no special methods.

    Has no special methods. Is here to provides erased identity for `TermName`.

    Definition Classes
      Names
36.  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
37.  trait TypeNameApi extends AnyRef

    Has no special methods.

    Has no special methods. Is here to provides erased identity for `TypeName`.

    Definition Classes
      Names
38.  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
39.  case class BooleanFlag(value: Option[Boolean]) extends Product with Serializable

    Definition Classes
      Printers
40.  trait TreePrinter extends AnyRef

    Attributes
      protected
    Definition Classes
      Printers
41.  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

42.  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
43.  trait MemberScopeApi extends Universe.ScopeApi

    The API that all member scopes support

    The API that all member scopes support

    Definition Classes
      Scopes
44.  abstract type Scope >: Null <: Universe.ScopeApi

    The base type of all scopes.

    The base type of all scopes.

    Definition Classes
      Scopes
45.  trait ScopeApi extends Iterable[Universe.Symbol]

    The API that all scopes support

    The API that all scopes support

    Definition Classes
      Scopes
46.  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
47.  trait StandardTypes extends AnyRef

    Defines standard types.

    Defines standard types.

    Definition Classes
      StandardDefinitions
48.  trait StandardLiftableInstances extends AnyRef
    Definition Classes
      StandardLiftables
49.  trait StandardUnliftableInstances extends AnyRef
    Definition Classes
      StandardLiftables
50.  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
51.  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
52.  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
53.  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
54.  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
55.  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
56.  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
57.  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
58.  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
59.  abstract type Symbol >: Null <: Universe.SymbolApi

    The type of symbols representing declarations.

    The type of symbols representing declarations.

    Definition Classes
      Symbols
60.  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
61.  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
62.  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
63.  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
64.  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
65.  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
66.  trait AlternativeApi extends Universe.TermTreeApi

    The API that all alternatives support

    The API that all alternatives support

    Definition Classes
      Trees
67.  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
68.  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
69.  trait AnnotatedApi extends Universe.TreeApi

    The API that all annotateds support

    The API that all annotateds support

    Definition Classes
      Trees
70.  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
71.  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
72.  trait AppliedTypeTreeApi extends Universe.TypTreeApi

    The API that all applied type trees support

    The API that all applied type trees support

    Definition Classes
      Trees
73.  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
74.  abstract type Apply >: Null <: Universe.ApplyApi with Universe.GenericApply

    Value application

    Value application

    Definition Classes
      Trees
75.  trait ApplyApi extends Universe.GenericApplyApi

    The API that all applies support

    The API that all applies support

    Definition Classes
      Trees
76.  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
77.  abstract type Assign >: Null <: Universe.AssignApi with Universe.TermTree

    Assignment

    Assignment

    Definition Classes
      Trees
78.  trait AssignApi extends Universe.TermTreeApi

    The API that all assigns support

    The API that all assigns support

    Definition Classes
      Trees
79.  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
80.  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
81.  trait AssignOrNamedArgApi extends Universe.TermTreeApi

    The API that all assigns support

    The API that all assigns support

    Definition Classes
      Trees
82.  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
83.  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
84.  trait BindApi extends Universe.DefTreeApi

    The API that all binds support

    The API that all binds support

    Definition Classes
      Trees
85.  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
86.  abstract type Block >: Null <: Universe.BlockApi with Universe.TermTree

    Block of expressions (semicolon separated expressions)

    Block of expressions (semicolon separated expressions)

    Definition Classes
      Trees
87.  trait BlockApi extends Universe.TermTreeApi

    The API that all blocks support

    The API that all blocks support

    Definition Classes
      Trees
88.  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
89.  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
90.  trait CaseDefApi extends Universe.TreeApi

    The API that all case defs support

    The API that all case defs support

    Definition Classes
      Trees
91.  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
92.  abstract type ClassDef >: Null <: Universe.ClassDefApi with Universe.ImplDef

    A class definition.

    A class definition.

    Definition Classes
      Trees
93.  trait ClassDefApi extends Universe.ImplDefApi

    The API that all class defs support

    The API that all class defs support

    Definition Classes
      Trees
94.  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
95.  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
96.  trait CompoundTypeTreeApi extends Universe.TypTreeApi

    The API that all compound type trees support

    The API that all compound type trees support

    Definition Classes
      Trees
97.  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
98.  abstract type DefDef >: Null <: Universe.DefDefApi with Universe.ValOrDefDef

    A method or macro definition.

    A method or macro definition.

    Definition Classes
      Trees
99.  trait DefDefApi extends Universe.ValOrDefDefApi

    The API that all def defs support

    The API that all def defs support

    Definition Classes
      Trees
100.  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
101.  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
102.  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
103.  abstract type ExistentialTypeTree >: Null <: Universe.ExistentialTypeTreeApi with Universe.TypTree

     Existential type tree node

     Existential type tree node

     Definition Classes
       Trees
104.  trait ExistentialTypeTreeApi extends Universe.TypTreeApi

     The API that all existential type trees support

     The API that all existential type trees support

     Definition Classes
       Trees
105.  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
106.  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
107.  trait FunctionApi extends Universe.TermTreeApi with Universe.SymTreeApi

     The API that all functions support

     The API that all functions support

     Definition Classes
       Trees
108.  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
109.  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
110.  trait GenericApplyApi extends Universe.TermTreeApi

     The API that all applies support

     The API that all applies support

     Definition Classes
       Trees
111.  abstract type Ident >: Null <: Universe.IdentApi with Universe.RefTree

     A reference to identifier `name`.

     A reference to identifier `name`.

     Definition Classes
       Trees
112.  trait IdentApi extends Universe.RefTreeApi

     The API that all idents support

     The API that all idents support

     Definition Classes
       Trees
113.  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
114.  abstract type If >: Null <: Universe.IfApi with Universe.TermTree

     Conditional expression

     Conditional expression

     Definition Classes
       Trees
115.  trait IfApi extends Universe.TermTreeApi

     The API that all ifs support

     The API that all ifs support

     Definition Classes
       Trees
116.  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
117.  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
118.  trait ImplDefApi extends Universe.MemberDefApi

     The API that all impl defs support

     The API that all impl defs support

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

     Import clause

     Import clause

     Definition Classes
       Trees
120.  trait ImportApi extends Universe.SymTreeApi

     The API that all imports support

     The API that all imports support

     Definition Classes
       Trees
121.  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
122.  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
123.  trait ImportSelectorApi extends AnyRef

     The API that all import selectors support

     The API that all import selectors support

     Definition Classes
       Trees
124.  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
125.  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
126.  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
127.  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
128.  abstract type Literal >: Null <: Universe.LiteralApi with Universe.TermTree

     Literal

     Literal

     Definition Classes
       Trees
129.  trait LiteralApi extends Universe.TermTreeApi

     The API that all literals support

     The API that all literals support

     Definition Classes
       Trees
130.  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
131.  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
132.  trait MatchApi extends Universe.TermTreeApi

     The API that all matches support

     The API that all matches support

     Definition Classes
       Trees
133.  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
134.  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
135.  trait MemberDefApi extends Universe.DefTreeApi

     The API that all member defs support

     The API that all member defs support

     Definition Classes
       Trees
136.  abstract class ModifiersApi extends AnyRef

     The API that all Modifiers support

     The API that all Modifiers support

     Definition Classes
       Trees
137.  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
138.  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
139.  trait ModuleDefApi extends Universe.ImplDefApi

     The API that all module defs support

     The API that all module defs support

     Definition Classes
       Trees
140.  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
141.  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
142.  trait NameTreeApi extends Universe.TreeApi

     The API that all name trees support

     The API that all name trees support

     Definition Classes
       Trees
143.  abstract type New >: Null <: Universe.NewApi with Universe.TermTree

     Object instantiation

     Object instantiation

     Definition Classes
       Trees
144.  trait NewApi extends Universe.TermTreeApi

     The API that all news support

     The API that all news support

     Definition Classes
       Trees
145.  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
146.  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
147.  trait PackageDefApi extends Universe.MemberDefApi

     The API that all package defs support

     The API that all package defs support

     Definition Classes
       Trees
148.  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
149.  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
150.  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
151.  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
152.  abstract type Return >: Null <: Universe.ReturnApi with Universe.SymTree with Universe.TermTree

     Return expression

     Return expression

     Definition Classes
       Trees
153.  trait ReturnApi extends Universe.TermTreeApi

     The API that all returns support

     The API that all returns support

     Definition Classes
       Trees
154.  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
155.  abstract type Select >: Null <: Universe.SelectApi with Universe.RefTree

     A member selection <qualifier> .

     A member selection <qualifier> . <name>

     Definition Classes
       Trees
156.  trait SelectApi extends Universe.RefTreeApi

     The API that all selects support

     The API that all selects support

     Definition Classes
       Trees
157.  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
158.  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
159.  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
160.  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
161.  abstract type SingletonTypeTree >: Null <: Universe.SingletonTypeTreeApi with Universe.TypTree

     Singleton type, eliminated by RefCheck

     Singleton type, eliminated by RefCheck

     Definition Classes
       Trees
162.  trait SingletonTypeTreeApi extends Universe.TypTreeApi

     The API that all singleton type trees support

     The API that all singleton type trees support

     Definition Classes
       Trees
163.  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
164.  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
165.  trait StarApi extends Universe.TermTreeApi

     The API that all stars support

     The API that all stars support

     Definition Classes
       Trees
166.  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
167.  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
168.  trait SuperApi extends Universe.TermTreeApi

     The API that all supers support

     The API that all supers support

     Definition Classes
       Trees
169.  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
170.  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
171.  trait SymTreeApi extends Universe.TreeApi

     The API that all sym trees support

     The API that all sym trees support

     Definition Classes
       Trees
172.  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
173.  trait TemplateApi extends Universe.SymTreeApi

     The API that all templates support

     The API that all templates support

     Definition Classes
       Trees
174.  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
175.  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
176.  trait TermTreeApi extends Universe.TreeApi

     The API that all term trees support

     The API that all term trees support

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

     Self reference

     Self reference

     Definition Classes
       Trees
178.  trait ThisApi extends Universe.TermTreeApi with Universe.SymTreeApi

     The API that all thises support

     The API that all thises support

     Definition Classes
       Trees
179.  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
180.  abstract type Throw >: Null <: Universe.ThrowApi with Universe.TermTree

     Throw expression

     Throw expression

     Definition Classes
       Trees
181.  trait ThrowApi extends Universe.TermTreeApi

     The API that all tries support

     The API that all tries support

     Definition Classes
       Trees
182.  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
183.  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
184.  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
185.  abstract type Tree >: Null <: Universe.TreeApi

     The type of Scala abstract syntax trees.

     The type of Scala abstract syntax trees.

     Definition Classes
       Trees
186.  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
187.  abstract type TreeCopier >: Null <: Universe.TreeCopierOps

     The type of standard (lazy) tree copiers.

     The type of standard (lazy) tree copiers.

     Definition Classes
       Trees
188.  abstract class TreeCopierOps extends AnyRef

     The API of a tree copier.

     The API of a tree copier.

     Definition Classes
       Trees
189.  abstract type Try >: Null <: Universe.TryApi with Universe.TermTree

     Try catch node

     Try catch node

     Definition Classes
       Trees
190.  trait TryApi extends Universe.TermTreeApi

     The API that all tries support

     The API that all tries support

     Definition Classes
       Trees
191.  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
192.  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
193.  trait TypTreeApi extends Universe.TreeApi

     The API that all typ trees support

     The API that all typ trees support

     Definition Classes
       Trees
194.  abstract type TypeApply >: Null <: Universe.TypeApplyApi with Universe.GenericApply

     Explicit type application.

     Explicit type application.

     Definition Classes
       Trees
195.  trait TypeApplyApi extends Universe.GenericApplyApi

     The API that all type applies support

     The API that all type applies support

     Definition Classes
       Trees
196.  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
197.  abstract type TypeBoundsTree >: Null <: Universe.TypeBoundsTreeApi with Universe.TypTree

     Type bounds tree node

     Type bounds tree node

     Definition Classes
       Trees
198.  trait TypeBoundsTreeApi extends Universe.TypTreeApi

     The API that all type bound trees support

     The API that all type bound trees support

     Definition Classes
       Trees
199.  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
200.  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
201.  trait TypeDefApi extends Universe.MemberDefApi

     The API that all type defs support

     The API that all type defs support

     Definition Classes
       Trees
202.  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
203.  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
204.  trait TypeTreeApi extends Universe.TypTreeApi

     The API that all type trees support

     The API that all type trees support

     Definition Classes
       Trees
205.  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
206.  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
207.  trait TypedApi extends Universe.TermTreeApi

     The API that all typeds support

     The API that all typeds support

     Definition Classes
       Trees
208.  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
209.  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
210.  trait UnApplyApi extends Universe.TermTreeApi

     The API that all unapplies support

     The API that all unapplies support

     Definition Classes
       Trees
211.  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
212.  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
213.  trait ValDefApi extends Universe.ValOrDefDefApi

     The API that all val defs support

     The API that all val defs support

     Definition Classes
       Trees
214.  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
215.  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
216.  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
217.  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

218.  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 `TypeTag`s are available for the referenced type arguments or abstract types, they are used to embed the concrete types into the WeakTypeTag. Otherwise the WeakTypeTag will contain a reference to an abstract type. This behavior can be useful, when one 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 `TypeTag`s, see the Reflection Guide: TypeTags

     Definition Classes
       TypeTags
     Annotations
       @implicitNotFound( "No WeakTypeTag available for ${T}" )
     See also

       scala.reflect.api.TypeTags

219.  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
220.  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
221.  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
222.  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:

     1. If the expected type of an expression is an existential type, its hidden symbols are replaced with bounded wildcards. 2. When an implicit conversion is being sought based in part on the name of a method in the converted type, a HasMethodMatching type is created: a MethodType with parameters typed as BoundedWildcardTypes.
     Definition Classes
       Types
223.  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
224.  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
225.  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
226.  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
227.  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
228.  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
229.  trait CompoundTypeApi extends AnyRef

     Has no special methods.

     Has no special methods. Is here to provides erased identity for `CompoundType`.

     Definition Classes
       Types
230.  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
231.  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
232.  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
233.  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
234.  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
235.  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
236.  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
237.  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
238.  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
239.  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
240.  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
241.  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
242.  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
243.  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
244.  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
245.  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
246.  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
247.  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
248.  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
249.  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
250.  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
251.  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
252.  trait SingletonTypeApi extends AnyRef

     Has no special methods.

     Has no special methods. Is here to provides erased identity for `SingletonType`.

     Definition Classes
       Types
253.  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
254.  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
255.  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
256.  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
257.  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
258.  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
259.  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
260.  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
261.  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
262.  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
263.  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
264.  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
265.  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
266.  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
267.  abstract type Compat <: MacroCompatApi

     Definition Classes
       Universe → Internals
268.  abstract type Internal <: MacroInternalApi

     Definition Classes
       Universe → Internals
269.  trait MacroCompatApi extends CompatApi

     See also

       compat

270.  trait MacroInternalApi extends InternalApi

     <invalid inheritdoc annotation>

271.  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
272.  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
273.  abstract type Name >: Null <: NameApi

     The abstract type of names.

     The abstract type of names.

     Definition Classes
       Names
274.  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
275.  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
276.  abstract type TermName >: Null <: TermNameApi with Name

     The abstract type of names representing types.

     The abstract type of names representing types.

     Definition Classes
       Names
277.  trait TreeGen extends AnyRef

278.  abstract type TypeName >: Null <: TypeNameApi with Name

     The abstract type of names representing terms.

     The abstract type of names representing terms.

     Definition Classes
       Names
279.  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

280.  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

281.  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

282.  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

283.  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

284.  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

285.  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

286.  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

287.  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

288.  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

289.  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

290.  type BuildApi = ReificationSupportApi
     Definition Classes
       Internals
     Annotations
       @deprecated
     Deprecated

       (Since version 2.11.0) use `internal.ReificationSupportApi` instead

291.  abstract type CompilationUnit <: CompilationUnitContextApi

     The type of compilation units.

     The type of compilation units.

     Annotations
       @deprecated
     Deprecated

       (Since version 2.11.0) c.enclosingTree-style APIs are now deprecated; consult the scaladoc for more information

     See also

       scala.reflect.macros.Enclosures

292.  trait CompilationUnitContextApi extends AnyRef

     Compilation unit describes a unit of work of the compilation run.

     Compilation unit describes a unit of work of the compilation run. It provides such information as file name, textual representation of the unit and the underlying AST.

     Annotations
       @deprecated
     Deprecated

       (Since version 2.11.0) c.enclosingTree-style APIs are now deprecated; consult the scaladoc for more information

     See also

       scala.reflect.macros.Enclosures

293.  type ModifiersCreator = ModifiersExtractor
     Definition Classes
       Trees
     Annotations
       @deprecated
     Deprecated

       (Since version 2.11.0) use ModifiersExtractor instead

294.  abstract type Run <: RunContextApi

     The type of compilation runs.

     The type of compilation runs.

     Annotations
       @deprecated
     Deprecated

       (Since version 2.11.0) c.enclosingTree-style APIs are now deprecated; consult the scaladoc for more information

     See also

       scala.reflect.macros.Enclosures

295.  trait RunContextApi extends AnyRef

     Compilation run uniquely identifies current invocation of the compiler (e.g.

     Compilation run uniquely identifies current invocation of the compiler (e.g. can be used to implement per-run caches for macros) and provides access to units of work of the invocation (currently processed unit of work and the list of all units).

     Annotations
       @deprecated
     Deprecated

       (Since version 2.11.0) c.enclosingTree-style APIs are now deprecated; consult the scaladoc for more information

     See also

       scala.reflect.macros.Enclosures

### Abstract Value Members

1.  abstract val Alternative: AlternativeExtractor

   The constructor/extractor for `Alternative` instances.

   The constructor/extractor for `Alternative` instances.

   Definition Classes
     Trees
2.  implicit abstract val AlternativeTag: ClassTag[Alternative]
   Definition Classes
     ImplicitTags
3.  abstract val Annotated: AnnotatedExtractor

   The constructor/extractor for `Annotated` instances.

   The constructor/extractor for `Annotated` instances.

   Definition Classes
     Trees
4.  implicit abstract val AnnotatedTag: ClassTag[Annotated]
   Definition Classes
     ImplicitTags
5.  abstract val AnnotatedType: AnnotatedTypeExtractor

   The constructor/extractor for `AnnotatedType` instances.

   The constructor/extractor for `AnnotatedType` instances.

   Definition Classes
     Types
6.  implicit abstract val AnnotatedTypeTag: ClassTag[AnnotatedType]
   Definition Classes
     ImplicitTags
7.  abstract val Annotation: AnnotationExtractor

   The constructor/extractor for `Annotation` instances.

   The constructor/extractor for `Annotation` instances.

   Definition Classes
     Annotations
8.  implicit abstract val AnnotationTag: ClassTag[Annotation]
   Definition Classes
     ImplicitTags
9.  abstract val AppliedTypeTree: AppliedTypeTreeExtractor

   The constructor/extractor for `AppliedTypeTree` instances.

   The constructor/extractor for `AppliedTypeTree` instances.

   Definition Classes
     Trees
10.  implicit abstract val AppliedTypeTreeTag: ClassTag[AppliedTypeTree]
    Definition Classes
      ImplicitTags
11.  abstract val Apply: ApplyExtractor

    The constructor/extractor for `Apply` instances.

    The constructor/extractor for `Apply` instances.

    Definition Classes
      Trees
12.  implicit abstract val ApplyTag: ClassTag[Apply]
    Definition Classes
      ImplicitTags
13.  implicit abstract val ArrayArgumentTag: ClassTag[ArrayArgument]
    Definition Classes
      ImplicitTags
14.  abstract val Assign: AssignExtractor

    The constructor/extractor for `Assign` instances.

    The constructor/extractor for `Assign` instances.

    Definition Classes
      Trees
15.  abstract val AssignOrNamedArg: AssignOrNamedArgExtractor

    The constructor/extractor for `AssignOrNamedArg` instances.

    The constructor/extractor for `AssignOrNamedArg` instances.

    Definition Classes
      Trees
16.  implicit abstract val AssignOrNamedArgTag: ClassTag[AssignOrNamedArg]
    Definition Classes
      ImplicitTags
17.  implicit abstract val AssignTag: ClassTag[Assign]
    Definition Classes
      ImplicitTags
18.  abstract val Bind: BindExtractor

    The constructor/extractor for `Bind` instances.

    The constructor/extractor for `Bind` instances.

    Definition Classes
      Trees
19.  implicit abstract val BindTag: ClassTag[Bind]
    Definition Classes
      ImplicitTags
20.  abstract val Block: BlockExtractor

    The constructor/extractor for `Block` instances.

    The constructor/extractor for `Block` instances.

    Definition Classes
      Trees
21.  implicit abstract val BlockTag: ClassTag[Block]
    Definition Classes
      ImplicitTags
22.  abstract val BoundedWildcardType: BoundedWildcardTypeExtractor

    The constructor/extractor for `BoundedWildcardType` instances.

    The constructor/extractor for `BoundedWildcardType` instances.

    Definition Classes
      Types
23.  implicit abstract val BoundedWildcardTypeTag: ClassTag[BoundedWildcardType]
    Definition Classes
      ImplicitTags
24.  abstract val CaseDef: CaseDefExtractor

    The constructor/extractor for `CaseDef` instances.

    The constructor/extractor for `CaseDef` instances.

    Definition Classes
      Trees
25.  implicit abstract val CaseDefTag: ClassTag[CaseDef]
    Definition Classes
      ImplicitTags
26.  abstract val ClassDef: ClassDefExtractor

    The constructor/extractor for `ClassDef` instances.

    The constructor/extractor for `ClassDef` instances.

    Definition Classes
      Trees
27.  implicit abstract val ClassDefTag: ClassTag[ClassDef]
    Definition Classes
      ImplicitTags
28.  abstract val ClassInfoType: ClassInfoTypeExtractor

    The constructor/extractor for `ClassInfoType` instances.

    The constructor/extractor for `ClassInfoType` instances.

    Definition Classes
      Types
29.  implicit abstract val ClassInfoTypeTag: ClassTag[ClassInfoType]
    Definition Classes
      ImplicitTags
30.  implicit abstract val ClassSymbolTag: ClassTag[ClassSymbol]
    Definition Classes
      ImplicitTags
31.  implicit abstract val CompoundTypeTag: ClassTag[CompoundType]
    Definition Classes
      ImplicitTags
32.  abstract val CompoundTypeTree: CompoundTypeTreeExtractor

    The constructor/extractor for `CompoundTypeTree` instances.

    The constructor/extractor for `CompoundTypeTree` instances.

    Definition Classes
      Trees
33.  implicit abstract val CompoundTypeTreeTag: ClassTag[CompoundTypeTree]
    Definition Classes
      ImplicitTags
34.  abstract val Constant: ConstantExtractor

    The constructor/extractor for `Constant` instances.

    The constructor/extractor for `Constant` instances.

    Definition Classes
      Constants
35.  implicit abstract val ConstantTag: ClassTag[Constant]
    Definition Classes
      ImplicitTags
36.  abstract val ConstantType: ConstantTypeExtractor

    The constructor/extractor for `ConstantType` instances.

    The constructor/extractor for `ConstantType` instances.

    Definition Classes
      Types
37.  implicit abstract val ConstantTypeTag: ClassTag[ConstantType]
    Definition Classes
      ImplicitTags
38.  abstract val DefDef: DefDefExtractor

    The constructor/extractor for `DefDef` instances.

    The constructor/extractor for `DefDef` instances.

    Definition Classes
      Trees
39.  implicit abstract val DefDefTag: ClassTag[DefDef]
    Definition Classes
      ImplicitTags
40.  implicit abstract val DefTreeTag: ClassTag[DefTree]
    Definition Classes
      ImplicitTags
41.  abstract val EmptyTree: Tree

    The empty tree

    The empty tree

    Definition Classes
      Trees
42.  abstract val ExistentialType: ExistentialTypeExtractor

    The constructor/extractor for `ExistentialType` instances.

    The constructor/extractor for `ExistentialType` instances.

    Definition Classes
      Types
43.  implicit abstract val ExistentialTypeTag: ClassTag[ExistentialType]
    Definition Classes
      ImplicitTags
44.  abstract val ExistentialTypeTree: ExistentialTypeTreeExtractor

    The constructor/extractor for `ExistentialTypeTree` instances.

    The constructor/extractor for `ExistentialTypeTree` instances.

    Definition Classes
      Trees
45.  implicit abstract val ExistentialTypeTreeTag: ClassTag[ExistentialTypeTree]
    Definition Classes
      ImplicitTags
46.  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
47.  implicit abstract val FlagSetTag: ClassTag[FlagSet]
    Definition Classes
      ImplicitTags
48.  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
49.  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
50.  abstract val Function: FunctionExtractor

    The constructor/extractor for `Function` instances.

    The constructor/extractor for `Function` instances.

    Definition Classes
      Trees
51.  implicit abstract val FunctionTag: ClassTag[Function]
    Definition Classes
      ImplicitTags
52.  implicit abstract val GenericApplyTag: ClassTag[GenericApply]
    Definition Classes
      ImplicitTags
53.  abstract def Ident(sym: Symbol): Ident

    A factory method for `Ident` nodes.

    A factory method for `Ident` nodes.

    Definition Classes
      Trees
54.  abstract val Ident: IdentExtractor

    The constructor/extractor for `Ident` instances.

    The constructor/extractor for `Ident` instances.

    Definition Classes
      Trees
55.  implicit abstract val IdentTag: ClassTag[Ident]
    Definition Classes
      ImplicitTags
56.  abstract val If: IfExtractor

    The constructor/extractor for `If` instances.

    The constructor/extractor for `If` instances.

    Definition Classes
      Trees
57.  implicit abstract val IfTag: ClassTag[If]
    Definition Classes
      ImplicitTags
58.  implicit abstract val ImplDefTag: ClassTag[ImplDef]
    Definition Classes
      ImplicitTags
59.  abstract val Import: ImportExtractor

    The constructor/extractor for `Import` instances.

    The constructor/extractor for `Import` instances.

    Definition Classes
      Trees
60.  abstract val ImportSelector: ImportSelectorExtractor

    The constructor/extractor for `ImportSelector` instances.

    The constructor/extractor for `ImportSelector` instances.

    Definition Classes
      Trees
61.  implicit abstract val ImportSelectorTag: ClassTag[ImportSelector]
    Definition Classes
      ImplicitTags
62.  implicit abstract val ImportTag: ClassTag[Import]
    Definition Classes
      ImplicitTags
63.  implicit abstract val JavaArgumentTag: ClassTag[JavaArgument]
    Definition Classes
      ImplicitTags
64.  abstract val LabelDef: LabelDefExtractor

    The constructor/extractor for `LabelDef` instances.

    The constructor/extractor for `LabelDef` instances.

    Definition Classes
      Trees
65.  implicit abstract val LabelDefTag: ClassTag[LabelDef]
    Definition Classes
      ImplicitTags
66.  abstract val Literal: LiteralExtractor

    The constructor/extractor for `Literal` instances.

    The constructor/extractor for `Literal` instances.

    Definition Classes
      Trees
67.  implicit abstract val LiteralArgumentTag: ClassTag[LiteralArgument]
    Definition Classes
      ImplicitTags
68.  implicit abstract val LiteralTag: ClassTag[Literal]
    Definition Classes
      ImplicitTags
69.  abstract val Match: MatchExtractor

    The constructor/extractor for `Match` instances.

    The constructor/extractor for `Match` instances.

    Definition Classes
      Trees
70.  implicit abstract val MatchTag: ClassTag[Match]
    Definition Classes
      ImplicitTags
71.  implicit abstract val MemberDefTag: ClassTag[MemberDef]
    Definition Classes
      ImplicitTags
72.  implicit abstract val MemberScopeTag: ClassTag[MemberScope]
    Definition Classes
      ImplicitTags
73.  implicit abstract val MethodSymbolTag: ClassTag[MethodSymbol]
    Definition Classes
      ImplicitTags
74.  abstract val MethodType: MethodTypeExtractor

    The constructor/extractor for `MethodType` instances.

    The constructor/extractor for `MethodType` instances.

    Definition Classes
      Types
75.  implicit abstract val MethodTypeTag: ClassTag[MethodType]
    Definition Classes
      ImplicitTags
76.  implicit abstract val MirrorTag: ClassTag[Mirror]
    Definition Classes
      ImplicitTags
77.  abstract val Modifiers: ModifiersExtractor

    The constructor/extractor for `Modifiers` instances.

    The constructor/extractor for `Modifiers` instances.

    Definition Classes
      Trees
78.  implicit abstract val ModifiersTag: ClassTag[Modifiers]
    Definition Classes
      ImplicitTags
79.  abstract val ModuleDef: ModuleDefExtractor

    The constructor/extractor for `ModuleDef` instances.

    The constructor/extractor for `ModuleDef` instances.

    Definition Classes
      Trees
80.  implicit abstract val ModuleDefTag: ClassTag[ModuleDef]
    Definition Classes
      ImplicitTags
81.  implicit abstract val ModuleSymbolTag: ClassTag[ModuleSymbol]
    Definition Classes
      ImplicitTags
82.  implicit abstract val NameTag: ClassTag[Name]
    Definition Classes
      ImplicitTags
83.  implicit abstract val NameTreeTag: ClassTag[NameTree]
    Definition Classes
      ImplicitTags
84.  implicit abstract val NestedArgumentTag: ClassTag[NestedArgument]
    Definition Classes
      ImplicitTags
85.  abstract val New: NewExtractor

    The constructor/extractor for `New` instances.

    The constructor/extractor for `New` instances.

    Definition Classes
      Trees
86.  implicit abstract val NewTag: ClassTag[New]
    Definition Classes
      ImplicitTags
87.  abstract val NoFlags: FlagSet

    The empty set of flags

    The empty set of flags

    Definition Classes
      FlagSets
88.  abstract val NoPosition: Position

    A special "missing" position.

    A special "missing" position.

    Definition Classes
      Positions
89.  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
90.  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
91.  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
92.  abstract val NullaryMethodType: NullaryMethodTypeExtractor

    The constructor/extractor for `NullaryMethodType` instances.

    The constructor/extractor for `NullaryMethodType` instances.

    Definition Classes
      Types
93.  implicit abstract val NullaryMethodTypeTag: ClassTag[NullaryMethodType]
    Definition Classes
      ImplicitTags
94.  abstract val PackageDef: PackageDefExtractor

    The constructor/extractor for `PackageDef` instances.

    The constructor/extractor for `PackageDef` instances.

    Definition Classes
      Trees
95.  implicit abstract val PackageDefTag: ClassTag[PackageDef]
    Definition Classes
      ImplicitTags
96.  abstract val PolyType: PolyTypeExtractor

    The constructor/extractor for `PolyType` instances.

    The constructor/extractor for `PolyType` instances.

    Definition Classes
      Types
97.  implicit abstract val PolyTypeTag: ClassTag[PolyType]
    Definition Classes
      ImplicitTags
98.  implicit abstract val PositionTag: ClassTag[Position]
    Definition Classes
      ImplicitTags
99.  abstract val RefTree: RefTreeExtractor

    The constructor/extractor for `RefTree` instances.

    The constructor/extractor for `RefTree` instances.

    Definition Classes
      Trees
100.  implicit abstract val RefTreeTag: ClassTag[RefTree]
     Definition Classes
       ImplicitTags
101.  abstract val ReferenceToBoxed: ReferenceToBoxedExtractor

     The constructor/extractor for `ReferenceToBoxed` instances.

     The constructor/extractor for `ReferenceToBoxed` instances.

     Definition Classes
       Internals
102.  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
103.  abstract val RefinedType: RefinedTypeExtractor

     The constructor/extractor for `RefinedType` instances.

     The constructor/extractor for `RefinedType` instances.

     Definition Classes
       Types
104.  implicit abstract val RefinedTypeTag: ClassTag[RefinedType]
     Definition Classes
       ImplicitTags
105.  abstract val Return: ReturnExtractor

     The constructor/extractor for `Return` instances.

     The constructor/extractor for `Return` instances.

     Definition Classes
       Trees
106.  implicit abstract val ReturnTag: ClassTag[Return]
     Definition Classes
       ImplicitTags
107.  implicit abstract val RuntimeClassTag: ClassTag[RuntimeClass]
     Definition Classes
       ImplicitTags
108.  implicit abstract val ScopeTag: ClassTag[Scope]
     Definition Classes
       ImplicitTags
109.  abstract def Select(qualifier: Tree, sym: Symbol): Select

     A factory method for `Select` nodes.

     A factory method for `Select` nodes.

     Definition Classes
       Trees
110.  abstract val Select: SelectExtractor

     The constructor/extractor for `Select` instances.

     The constructor/extractor for `Select` instances.

     Definition Classes
       Trees
111.  abstract val SelectFromTypeTree: SelectFromTypeTreeExtractor

     The constructor/extractor for `SelectFromTypeTree` instances.

     The constructor/extractor for `SelectFromTypeTree` instances.

     Definition Classes
       Trees
112.  implicit abstract val SelectFromTypeTreeTag: ClassTag[SelectFromTypeTree]
     Definition Classes
       ImplicitTags
113.  implicit abstract val SelectTag: ClassTag[Select]
     Definition Classes
       ImplicitTags
114.  abstract val SingleType: SingleTypeExtractor

     The constructor/extractor for `SingleType` instances.

     The constructor/extractor for `SingleType` instances.

     Definition Classes
       Types
115.  implicit abstract val SingleTypeTag: ClassTag[SingleType]
     Definition Classes
       ImplicitTags
116.  implicit abstract val SingletonTypeTag: ClassTag[SingletonType]
     Definition Classes
       ImplicitTags
117.  abstract val SingletonTypeTree: SingletonTypeTreeExtractor

     The constructor/extractor for `SingletonTypeTree` instances.

     The constructor/extractor for `SingletonTypeTree` instances.

     Definition Classes
       Trees
118.  implicit abstract val SingletonTypeTreeTag: ClassTag[SingletonTypeTree]
     Definition Classes
       ImplicitTags
119.  abstract val Star: StarExtractor

     The constructor/extractor for `Star` instances.

     The constructor/extractor for `Star` instances.

     Definition Classes
       Trees
120.  implicit abstract val StarTag: ClassTag[Star]
     Definition Classes
       ImplicitTags
121.  abstract val Super: SuperExtractor

     The constructor/extractor for `Super` instances.

     The constructor/extractor for `Super` instances.

     Definition Classes
       Trees
122.  implicit abstract val SuperTag: ClassTag[Super]
     Definition Classes
       ImplicitTags
123.  abstract val SuperType: SuperTypeExtractor

     The constructor/extractor for `SuperType` instances.

     The constructor/extractor for `SuperType` instances.

     Definition Classes
       Types
124.  implicit abstract val SuperTypeTag: ClassTag[SuperType]
     Definition Classes
       ImplicitTags
125.  implicit abstract val SymTreeTag: ClassTag[SymTree]
     Definition Classes
       ImplicitTags
126.  implicit abstract val SymbolTag: ClassTag[Symbol]
     Definition Classes
       ImplicitTags
127.  abstract val Template: TemplateExtractor

     The constructor/extractor for `Template` instances.

     The constructor/extractor for `Template` instances.

     Definition Classes
       Trees
128.  implicit abstract val TemplateTag: ClassTag[Template]
     Definition Classes
       ImplicitTags
129.  abstract val TermName: TermNameExtractor

     The constructor/extractor for `TermName` instances.

     The constructor/extractor for `TermName` instances.

     Definition Classes
       Names
130.  implicit abstract val TermNameTag: ClassTag[TermName]
     Definition Classes
       ImplicitTags
131.  implicit abstract val TermSymbolTag: ClassTag[TermSymbol]
     Definition Classes
       ImplicitTags
132.  implicit abstract val TermTreeTag: ClassTag[TermTree]
     Definition Classes
       ImplicitTags
133.  abstract def This(sym: Symbol): Tree

     A factory method for `This` nodes.

     A factory method for `This` nodes.

     Definition Classes
       Trees
134.  abstract val This: ThisExtractor

     The constructor/extractor for `This` instances.

     The constructor/extractor for `This` instances.

     Definition Classes
       Trees
135.  implicit abstract val ThisTag: ClassTag[This]
     Definition Classes
       ImplicitTags
136.  abstract val ThisType: ThisTypeExtractor

     The constructor/extractor for `ThisType` instances.

     The constructor/extractor for `ThisType` instances.

     Definition Classes
       Types
137.  implicit abstract val ThisTypeTag: ClassTag[ThisType]
     Definition Classes
       ImplicitTags
138.  abstract val Throw: ThrowExtractor

     The constructor/extractor for `Throw` instances.

     The constructor/extractor for `Throw` instances.

     Definition Classes
       Trees
139.  implicit abstract val ThrowTag: ClassTag[Throw]
     Definition Classes
       ImplicitTags
140.  implicit abstract val TreeCopierTag: ClassTag[TreeCopier]
     Definition Classes
       ImplicitTags
141.  implicit abstract val TreeTag: ClassTag[Tree]
     Definition Classes
       ImplicitTags
142.  abstract val Try: TryExtractor

     The constructor/extractor for `Try` instances.

     The constructor/extractor for `Try` instances.

     Definition Classes
       Trees
143.  implicit abstract val TryTag: ClassTag[Try]
     Definition Classes
       ImplicitTags
144.  implicit abstract val TypTreeTag: ClassTag[TypTree]
     Definition Classes
       ImplicitTags
145.  abstract val TypeApply: TypeApplyExtractor

     The constructor/extractor for `TypeApply` instances.

     The constructor/extractor for `TypeApply` instances.

     Definition Classes
       Trees
146.  implicit abstract val TypeApplyTag: ClassTag[TypeApply]
     Definition Classes
       ImplicitTags
147.  abstract val TypeBounds: TypeBoundsExtractor

     The constructor/extractor for `TypeBounds` instances.

     The constructor/extractor for `TypeBounds` instances.

     Definition Classes
       Types
148.  implicit abstract val TypeBoundsTag: ClassTag[TypeBounds]
     Definition Classes
       ImplicitTags
149.  abstract val TypeBoundsTree: TypeBoundsTreeExtractor

     The constructor/extractor for `TypeBoundsTree` instances.

     The constructor/extractor for `TypeBoundsTree` instances.

     Definition Classes
       Trees
150.  implicit abstract val TypeBoundsTreeTag: ClassTag[TypeBoundsTree]
     Definition Classes
       ImplicitTags
151.  abstract val TypeDef: TypeDefExtractor

     The constructor/extractor for `TypeDef` instances.

     The constructor/extractor for `TypeDef` instances.

     Definition Classes
       Trees
152.  implicit abstract val TypeDefTag: ClassTag[TypeDef]
     Definition Classes
       ImplicitTags
153.  abstract val TypeName: TypeNameExtractor

     The constructor/extractor for `TypeName` instances.

     The constructor/extractor for `TypeName` instances.

     Definition Classes
       Names
154.  implicit abstract val TypeNameTag: ClassTag[TypeName]
     Definition Classes
       ImplicitTags
155.  abstract val TypeRef: TypeRefExtractor

     The constructor/extractor for `TypeRef` instances.

     The constructor/extractor for `TypeRef` instances.

     Definition Classes
       Types
156.  implicit abstract val TypeRefTag: ClassTag[TypeRef]
     Definition Classes
       ImplicitTags
157.  implicit abstract val TypeSymbolTag: ClassTag[TypeSymbol]
     Definition Classes
       ImplicitTags
158.  implicit abstract val TypeTagg: ClassTag[Type]
     Definition Classes
       ImplicitTags
159.  abstract def TypeTree(tp: Type): TypeTree

     A factory method for `TypeTree` nodes.

     A factory method for `TypeTree` nodes.

     Definition Classes
       Trees
160.  abstract val TypeTree: TypeTreeExtractor

     The constructor/extractor for `TypeTree` instances.

     The constructor/extractor for `TypeTree` instances.

     Definition Classes
       Trees
161.  implicit abstract val TypeTreeTag: ClassTag[TypeTree]
     Definition Classes
       ImplicitTags
162.  abstract val Typed: TypedExtractor

     The constructor/extractor for `Typed` instances.

     The constructor/extractor for `Typed` instances.

     Definition Classes
       Trees
163.  implicit abstract val TypedTag: ClassTag[Typed]
     Definition Classes
       ImplicitTags
164.  abstract val UnApply: UnApplyExtractor

     The constructor/extractor for `UnApply` instances.

     The constructor/extractor for `UnApply` instances.

     Definition Classes
       Trees
165.  implicit abstract val UnApplyTag: ClassTag[UnApply]
     Definition Classes
       ImplicitTags
166.  abstract val ValDef: ValDefExtractor

     The constructor/extractor for `ValDef` instances.

     The constructor/extractor for `ValDef` instances.

     Definition Classes
       Trees
167.  implicit abstract val ValDefTag: ClassTag[ValDef]
     Definition Classes
       ImplicitTags
168.  implicit abstract val ValOrDefDefTag: ClassTag[ValOrDefDef]
     Definition Classes
       ImplicitTags
169.  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
170.  implicit abstract def addFlagOps(left: FlagSet): FlagOps

     The API of `FlagSet` instances.

     The API of `FlagSet` instances.

     Definition Classes
       FlagSets
171.  abstract def annotationToTree(ann: Annotation): Tree
     Attributes
       protected[scala]
     Definition Classes
       Annotations
172.  abstract def appliedType(sym: Symbol, args: Type*): Type

     Definition Classes
       Types
     See also

       appliedType

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

     Definition Classes
       Types
     See also

       appliedType

174.  abstract def appliedType(tycon: Type, args: Type*): Type

     Definition Classes
       Types
     See also

       appliedType

175.  abstract def appliedType(tycon: Type, args: List[Type]): Type

     A creator for type applications

     A creator for type applications

     Definition Classes
       Types
176.  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
177.  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
178.  abstract val definitions: DefinitionsApi

     A value containing all standard definitions in DefinitionsApi

     A value containing all standard definitions in DefinitionsApi

     Definition Classes
       StandardDefinitions
179.  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
180.  abstract val internal: Internal

     Definition Classes
       Internals
     See also

       InternalApi

181.  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
182.  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
183.  abstract def newLazyTreeCopier: TreeCopier

     Creates a lazy tree copier.

     Creates a lazy tree copier.

     Definition Classes
       Trees
184.  abstract def newRawTreePrinter(out: PrintWriter): TreePrinter

     Hook to define what `showRaw(...)` means.

     Hook to define what `showRaw(...)` means.

     Attributes
       protected
     Definition Classes
       Printers
185.  abstract def newStrictTreeCopier: TreeCopier

     Creates a strict tree copier.

     Creates a strict tree copier.

     Definition Classes
       Trees
186.  abstract def newTreePrinter(out: PrintWriter): TreePrinter

     Hook to define what `show(...)` means.

     Hook to define what `show(...)` means.

     Attributes
       protected
     Definition Classes
       Printers
187.  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
188.  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
189.  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
190.  abstract def show(position: Position): String

     Renders a prettified representation of a position.

     Renders a prettified representation of a position.

     Definition Classes
       Printers
191.  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
192.  abstract def show(name: Name): String

     Renders a prettified representation of a name.

     Renders a prettified representation of a name.

     Definition Classes
       Printers
193.  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
194.  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
195.  abstract val termNames: TermNamesApi

     A value containing all standard term names.

     A value containing all standard term names.

     Definition Classes
       StandardNames
196.  abstract def treeToAnnotation(tree: Tree): Annotation
     Attributes
       protected[scala]
     Definition Classes
       Annotations
197.  abstract val typeNames: TypeNamesApi

     A value containing all standard type names.

     A value containing all standard type names.

     Definition Classes
       StandardNames
198.  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
199.  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
200.  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

201.  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

202.  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

203.  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

204.  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

205.  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

206.  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

207.  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

208.  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

209.  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

210.  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

211.  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

212.  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

213.  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

214.  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

215.  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

216.  abstract val build: ReificationSupportApi
     Definition Classes
       Internals
     Annotations
       @deprecated
     Deprecated

       (Since version 2.11.0) use `internal.reificationSupport` instead

217.  abstract val emptyValDef: ValDef
     Definition Classes
       Trees
     Annotations
       @deprecated
     Deprecated

       (Since version 2.11.0) use `noSelfType` instead

218.  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

219.  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

220.  abstract val nme: TermNamesApi

     Definition Classes
       StandardNames
     Annotations
       @deprecated
     Deprecated

       (Since version 2.11.0) use `termNames` instead

     See also

       termNames

221.  abstract val tpnme: TypeNamesApi

     Definition Classes
       StandardNames
     Annotations
       @deprecated
     Deprecated

       (Since version 2.11.0) use `typeNames` instead

     See also

       typeNames

222.  abstract val treeBuild: TreeGen

     Annotations
       @deprecated
     Deprecated

       (Since version 2.11.0) use `internal.gen` instead

     See also

       internal.gen

### Concrete Value Members

1.  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
2.  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
3.  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
4.  object BooleanFlag extends Serializable

   Definition Classes
     Printers
5.  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
6.  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
7.  final def !=(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
8.  final def ##(): Int
   Definition Classes
     AnyRef → Any
9.  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
10.  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()
11.  final def ==(arg0: Any): Boolean
    Definition Classes
      AnyRef → Any
12.  def Modifiers(flags: FlagSet): Modifiers

    The factory for `Modifiers` instances.

    The factory for `Modifiers` instances.

    Definition Classes
      Trees
13.  def Modifiers(flags: FlagSet, privateWithin: Name): Modifiers

    The factory for `Modifiers` instances.

    The factory for `Modifiers` instances.

    Definition Classes
      Trees
14.  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
15.  final def asInstanceOf[T0]: T0
    Definition Classes
      Any
16.  def clone(): AnyRef
    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( ... ) @native()
17.  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
18.  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
19.  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
20.  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
21.  final def eq(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
22.  def equals(arg0: Any): Boolean
    Definition Classes
      AnyRef → Any
23.  def finalize(): Unit
    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( classOf[java.lang.Throwable] )
24.  final def getClass(): Class[_]
    Definition Classes
      AnyRef → Any
    Annotations
      @native()
25.  def hashCode(): Int
    Definition Classes
      AnyRef → Any
    Annotations
      @native()
26.  final def isInstanceOf[T0]: Boolean
    Definition Classes
      Any
27.  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
28.  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
29.  final def ne(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
30.  final def notify(): Unit
    Definition Classes
      AnyRef
    Annotations
      @native()
31.  final def notifyAll(): Unit
    Definition Classes
      AnyRef
    Annotations
      @native()
32.  macro def reify[T](expr: T): Expr[T]

    Use `reify` to produce the abstract syntax tree representing a given Scala expression.

    Use `reify` to produce the abstract syntax tree representing a given Scala expression.

    For example:

        val five = reify{ 5 }         // Literal(Constant(5))
        reify{ 5.toString }           // Apply(Select(Literal(Constant(5)), TermName("toString")), List())
        reify{ five.splice.toString } // Apply(Select(five, TermName("toString")), List())

    The produced tree is path dependent on the Universe `reify` was called from.

    Use scala.reflect.api.Exprs#Expr.splice to embed an existing expression into a `reify` call. Use Expr to turn a Tree into an expression that can be spliced.

    Definition Classes
      Universe
33.  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
34.  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
35.  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
36.  def showRaw(position: Position): String

    Renders internal structure of a position.

    Renders internal structure of a position.

    Definition Classes
      Printers
37.  def showRaw(flags: FlagSet): String

    Renders internal structure of a flag set.

    Renders internal structure of a flag set.

    Definition Classes
      Printers
38.  def showRaw(name: Name): String

    Renders internal structure of a name.

    Renders internal structure of a name.

    Definition Classes
      Printers
39.  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
40.  final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
      AnyRef
41.  def toString(): String
    Definition Classes
      AnyRef → Any
42.  val treeCopy: TreeCopier

    The standard (lazy) tree copier.

    The standard (lazy) tree copier.

    Definition Classes
      Trees
43.  def treeToString(tree: Tree): String

    By default trees are printed with `show`

    By default trees are printed with `show`

    Attributes
      protected
    Definition Classes
      Printers
44.  def typeOf[T](implicit ttag: TypeTag[T]): Type

    Shortcut for `implicitly[TypeTag[T]].tpe`

    Shortcut for `implicitly[TypeTag[T]].tpe`

    Definition Classes
      TypeTags
45.  def typeTag[T](implicit ttag: TypeTag[T]): TypeTag[T]

    Shortcut for `implicitly[TypeTag[T]]`

    Shortcut for `implicitly[TypeTag[T]]`

    Definition Classes
      TypeTags
46.  final def wait(): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )
47.  final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )
48.  final def wait(arg0: Long): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws( ... ) @native()
49.  def weakTypeOf[T](implicit attag: WeakTypeTag[T]): Type

    Shortcut for `implicitly[WeakTypeTag[T]].tpe`

    Shortcut for `implicitly[WeakTypeTag[T]].tpe`

    Definition Classes
      TypeTags
50.  def weakTypeTag[T](implicit attag: WeakTypeTag[T]): WeakTypeTag[T]

    Shortcut for `implicitly[WeakTypeTag[T]]`

    Shortcut for `implicitly[WeakTypeTag[T]]`

    Definition Classes
      TypeTags
51.  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
52.  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
53.  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

1.  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.

2.  def mkImporter(from0: api.Universe): Importer { val from: from0.type }
   Definition Classes
     Internals
   Annotations
     @deprecated
   Deprecated

     (Since version 2.11.0) use `internal.createImporter` instead

3.  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

4.  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 api.Universe

### Inherited from api.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 api.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]

### Macro Specific Additions

### Universe

### API

### Annotations

### Constants

### Definitions

### Expressions

### Extractors

### Flags

### Internal

### Mirrors

### Names

### Positions

### Printers

### Scopes

### Standard Names

### Symbols

### Trees

### Types - Operations

### TypeTags

### Types

### Tree Copying

### Factories

### Tree Traversal and Transformation

### Ungrouped