W3cubDocs

/Scala 2.12 Reflection

Trait scala.reflect.macros.Reifiers

trait Reifiers extends AnyRef

EXPERIMENTAL

A slice of the Scala macros context that exposes functions to save reflection artifacts for runtime.

Self Type
blackbox.Context
Source
Reifiers.scala
Linear Supertypes
Known Subclasses

Abstract Value Members

abstract def reifyEnclosingRuntimeClass: blackbox.Context.Tree

Given a type, generate a tree that when compiled and executed produces the runtime class of the enclosing class or module. Returns EmptyTree if there does not exist an enclosing class or module.

abstract def reifyRuntimeClass(tpe: blackbox.Context.Type, concrete: Boolean = true): blackbox.Context.Tree

Given a type, generate a tree that when compiled and executed produces the runtime class of the original type. If concrete is true, then this function will bail on types, who refer to abstract types (like ClassTag does).

abstract def reifyTree(universe: blackbox.Context.Tree, mirror: blackbox.Context.Tree, tree: blackbox.Context.Tree): blackbox.Context.Tree

Given a tree, generate a tree that when compiled and executed produces the original tree. For more information and examples see the documentation for Universe.reify.

The produced tree will be bound to the specified universe and mirror. Possible values for universe include universe.internal.gen.mkRuntimeUniverseRef. Possible values for mirror include EmptyTree (in that case the reifier will automatically pick an appropriate mirror).

This function is deeply connected to Universe.reify, a macro that reifies arbitrary expressions into runtime trees. They do very similar things (Universe.reify calls Context.reifyTree to implement itself), but they operate on different metalevels (see below).

Let's study the differences between Context.reifyTree and Universe.reify on an example of using them inside a fooMacro macro:

* Since reify itself is a macro, it will be executed when fooMacro is being compiled (metalevel -1) and will produce a tree that when evaluated during macro expansion of fooMacro (metalevel 0) will recreate the input tree.

This provides a facility analogous to quasi-quoting. Writing "reify{ expr }" will generate an AST that represents expr. Afterwards this AST (or its parts) can be used to construct the return value of fooMacro.

* reifyTree is evaluated during macro expansion (metalevel 0) and will produce a tree that when evaluated during the runtime of the program (metalevel 1) will recreate the input tree.

This provides a way to retain certain trees from macro expansion time to be inspected later, in the runtime. For example, DSL authors may find it useful to capture DSL snippets into ASTs that are then processed at runtime in a domain-specific way.

Also note the difference between universes of the runtime trees produced by two reifies:

* The result of compiling and running the result of reify will be bound to the Universe that called reify. This is possible because it's a macro, so it can generate whatever code it wishes.

* The result of compiling and running the result of reifyTree will be the prefix that needs to be passed explicitly. This happens because the Universe of the evaluated result is from a different metalevel than the Context the called reify.

Typical usage of this function is to retain some of the trees received/created by a macro into the form that can be inspected (via pattern matching) or compiled/run (by a reflective ToolBox) during the runtime.

abstract def reifyType(universe: blackbox.Context.Tree, mirror: blackbox.Context.Tree, tpe: blackbox.Context.Type, concrete: Boolean = false): blackbox.Context.Tree

Given a type, generate a tree that when compiled and executed produces the original type. The produced tree will be bound to the specified universe and mirror. For more information and examples see the documentation for Context.reifyTree and Universe.reify.

abstract def unreifyTree(tree: blackbox.Context.Tree): blackbox.Context.Tree

Undoes reification of a tree.

This reversion doesn't simply restore the original tree (that would lose the context of reification), but does something more involved that conforms to the following laws:

1) unreifyTree(reifyTree(tree)) != tree // unreified tree is tree + saved context // in current implementation, the result of unreify is opaque // i.e. there's no possibility to inspect underlying tree/context

2) reifyTree(unreifyTree(reifyTree(tree))) == reifyTree(tree) // the result of reifying a tree in its original context equals to // the result of reifying a tree along with its saved context

3) compileAndEval(unreifyTree(reifyTree(tree))) ~ compileAndEval(tree) // at runtime original and unreified trees are behaviorally equivalent

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any

final def ##(): Int

Definition Classes
AnyRef → Any

def +(other: String): String

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

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

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

final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any

final def asInstanceOf[T0]: T0

Definition Classes
Any

def clone(): AnyRef

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

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

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

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

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

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

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

def ensuring(cond: Boolean): Reifiers

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

final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef

def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any

def finalize(): Unit

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

def formatted(fmtstr: String): String

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

final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@native()

def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@native()

final def isInstanceOf[T0]: Boolean

Definition Classes
Any

final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef

final def notify(): Unit

Definition Classes
AnyRef
Annotations
@native()

final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@native()

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

Definition Classes
AnyRef

def toString(): String

Definition Classes
AnyRef → Any

final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

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

Definition Classes
AnyRef
Annotations
@throws( ... )

final def wait(arg0: Long): Unit

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

def [B](y: B): (Reifiers, B)

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

© 2002-2019 EPFL, with contributions from Lightbend.
Licensed under the Apache License, Version 2.0.
https://www.scala-lang.org/api/2.12.9/scala-reflect/scala/reflect/macros/Reifiers.html