Scala Reflection Library2.13.5 < Back


# Packages

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

  EXPERIMENTAL

  EXPERIMENTAL

  The Scala Reflection API (located in scala-reflect.jar).

  In Scala 2.10.0, the Scala Reflection API and its implementation have an "experimental" status. This means that the API and the docs are not complete and can be changed in binary- and source-incompatible manner in 2.10.1. This also means that the implementation has some known issues.

  The following types are the backbone of the Scala Reflection API, and serve as a good starting point for information about Scala Reflection:

  - scala.reflect.api.Symbols
  - scala.reflect.api.Types
  - scala.reflect.api.Mirrors
  - scala.reflect.api.Universe

  For more information about Scala Reflection, see the Reflection Guide

  Definition Classes
    reflect
- Annotations
- Constants
- Exprs
- FlagSets
- ImplicitTags
- Internals
- JavaUniverse
- Liftables
- Mirror
- Mirrors
- Names
- Position
- Positions
- Printers
- Quasiquotes
- Scopes
- StandardDefinitions
- StandardLiftables
- StandardNames
- Symbols
- TreeCreator
- Trees
- TypeCreator
- TypeTags
- Types
- Universe

t

scala.reflect.api

# Internals

###

#### trait Internals extends AnyRef

EXPERIMENTAL

This trait assembles APIs occasionally necessary for performing low-level operations on reflection artifacts. See Internals#InternalApi for more information about nature, usefulness and compatibility guarantees of these APIs.

Self Type
  Universe
Source
  Internals.scala

Linear Supertypes
AnyRef, Any
Known Subclasses
JavaUniverse, Universe, Universe
Type Hierarchy

Ordering

1. Grouped
2. Alphabetic
3. By Inheritance

Inherited

1. Internals
2. AnyRef
3. Any

Implicitly

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

1. Hide All
2. Show All

Visibility

1. Public
2. Protected

### Type Members

1.  abstract type FreeTermSymbol >: Null <: Universe.FreeTermSymbolApi with Universe.TermSymbol

   The type of free terms introduced by reification.

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

3.  abstract type FreeTypeSymbol >: Null <: Universe.FreeTypeSymbolApi with Universe.TypeSymbol

   The type of free types introduced by reification.

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

5.  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]
         ...
       }

6.  abstract type Internal <: Universe.InternalApi

   See also

     InternalApi

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

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

9.  trait ReferenceToBoxedApi extends Universe.TermTreeApi

   The API that all references support

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

11.  trait ReificationSupportApi extends AnyRef

    This is an internal implementation class.

### Deprecated Type Members

1.  abstract type Compat <: Universe.CompatApi

   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) compatibility with Scala 2.10 EOL

   See also

     compat

2.  trait CompatApi extends AnyRef

   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) compatibility with Scala 2.10 EOL

   See also

     compat

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

   Annotations
     @implicitNotFound("This method has been removed from the public API. Import compat._ or migrate away.") @deprecated
   Deprecated

     (Since version 2.13.0) compatibility with Scala 2.10 EOL

### Abstract Value Members

1.  implicit abstract val FreeTermSymbolTag: ClassTag[Universe.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.

2.  implicit abstract val FreeTypeSymbolTag: ClassTag[Universe.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.

3.  abstract val ReferenceToBoxed: Universe.ReferenceToBoxedExtractor

   The constructor/extractor for `ReferenceToBoxed` instances.

4.  implicit abstract val ReferenceToBoxedTag: ClassTag[Universe.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.

5.  abstract val internal: Universe.Internal

   See also

     InternalApi

6.  abstract val compat: Universe.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.

   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) compatibility with Scala 2.10 EOL

### Concrete Value Members

1.  final def !=(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
2.  final def ##: Int
   Definition Classes
     AnyRef → Any
3.  def +(other: String): String
   Implicit
     This member is added by an implicit conversion from Internals toany2stringadd[Internals] performed by method any2stringadd in scala.Predef.
   Definition Classes
     any2stringadd
4.  def ->[B](y: B): (Internals, B)
   Implicit
     This member is added by an implicit conversion from Internals toArrowAssoc[Internals] performed by method ArrowAssoc in scala.Predef.
   Definition Classes
     ArrowAssoc
   Annotations
     @inline()
5.  final def ==(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
6.  final def asInstanceOf[T0]: T0
   Definition Classes
     Any
7.  def clone(): AnyRef
   Attributes
     protected[lang]
   Definition Classes
     AnyRef
   Annotations
     @throws(classOf[java.lang.CloneNotSupportedException]) @native()
8.  def ensuring(cond: (Internals) => Boolean, msg: => Any): Internals
   Implicit
     This member is added by an implicit conversion from Internals toEnsuring[Internals] performed by method Ensuring in scala.Predef.
   Definition Classes
     Ensuring
9.  def ensuring(cond: (Internals) => Boolean): Internals
   Implicit
     This member is added by an implicit conversion from Internals toEnsuring[Internals] performed by method Ensuring in scala.Predef.
   Definition Classes
     Ensuring
10.  def ensuring(cond: Boolean, msg: => Any): Internals
    Implicit
      This member is added by an implicit conversion from Internals toEnsuring[Internals] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
11.  def ensuring(cond: Boolean): Internals
    Implicit
      This member is added by an implicit conversion from Internals toEnsuring[Internals] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
12.  final def eq(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
13.  def equals(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef → Any
14.  def finalize(): Unit
    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws(classOf[java.lang.Throwable])
15.  def formatted(fmtstr: String): String
    Implicit
      This member is added by an implicit conversion from Internals toStringFormat[Internals] performed by method StringFormat in scala.Predef.
    Definition Classes
      StringFormat
    Annotations
      @inline()
16.  final def getClass(): Class[_ <: AnyRef]
    Definition Classes
      AnyRef → Any
    Annotations
      @native()
17.  def hashCode(): Int
    Definition Classes
      AnyRef → Any
    Annotations
      @native()
18.  final def isInstanceOf[T0]: Boolean
    Definition Classes
      Any
19.  final def ne(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
20.  final def notify(): Unit
    Definition Classes
      AnyRef
    Annotations
      @native()
21.  final def notifyAll(): Unit
    Definition Classes
      AnyRef
    Annotations
      @native()
22.  final def synchronized[T0](arg0: => T0): T0
    Definition Classes
      AnyRef
23.  def toString(): String
    Definition Classes
      AnyRef → Any
24.  final def wait(): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws(classOf[java.lang.InterruptedException])
25.  final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws(classOf[java.lang.InterruptedException])
26.  final def wait(arg0: Long): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws(classOf[java.lang.InterruptedException]) @native()

### Deprecated Value Members

1.  def mkImporter(from0: Universe): Universe.Importer { val from: from0.type }
   Annotations
     @deprecated
   Deprecated

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

2.  def →[B](y: B): (Internals, B)
   Implicit
     This member is added by an implicit conversion from Internals toArrowAssoc[Internals] performed by method ArrowAssoc in scala.Predef.
   Definition Classes
     ArrowAssoc
   Annotations
     @deprecated
   Deprecated

     (Since version 2.13.0) Use `->` instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.

### Inherited from AnyRef

### Inherited from Any

### Inherited by implicit conversion any2stringadd fromInternals to any2stringadd[Internals]

### Inherited by implicit conversion StringFormat fromInternals to StringFormat[Internals]

### Inherited by implicit conversion Ensuring fromInternals to Ensuring[Internals]

### Inherited by implicit conversion ArrowAssoc fromInternals to ArrowAssoc[Internals]

### Internal

### Ungrouped