Scala Compiler2.12.3-1 < Back
 

# Packages

-  package root

  The Scala compiler and reflection APIs.

  The Scala compiler and reflection APIs.

  Definition Classes
    root
-  package scala
  Definition Classes
    root
-  package reflect
  Definition Classes
    scala
-  package quasiquotes
  Definition Classes
    reflect
-  trait Reifiers extends AnyRef
  Definition Classes
    quasiquotes
- ApplyReifier
- Reifier
- UnapplyReifier

c

scala.reflect.quasiquotes.Reifiers

# UnapplyReifier 

###

#### class UnapplyReifier extends Quasiquotes.Reifier

Source
  Reifiers.scala

Linear Supertypes
Quasiquotes.Reifier, reify.Reifier, Utils, StdAttachments, SymbolTables, Extractors, NodePrinters, Errors, Phases, Reify, GenUtils, GenPositions, GenAnnotationInfos, GenTrees, GenNames, GenTypes, GenSymbols, Metalevels, Calculate, Reshape, States, AnyRef, Any
Type Hierarchy
 
Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. UnapplyReifier
2. Reifier
3. Reifier
4. Utils
5. StdAttachments
6. SymbolTables
7. Extractors
8. NodePrinters
9. Errors
10. Phases
11. Reify
12. GenUtils
13. GenPositions
14. GenAnnotationInfos
15. GenTrees
16. GenNames
17. GenTypes
18. GenSymbols
19. Metalevels
20. Calculate
21. Reshape
22. States
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 UnapplyReifier()

### Type Members

1.  class State extends AnyRef
   Definition Classes
     States
2.  case class Reification (name: tools.nsc.Global.Name, binding: tools.nsc.Global.Tree, tree: tools.nsc.Global.Tree) extends Product with Serializable
   Definition Classes
     GenSymbols
3.  implicit class RichCalculateSymbol extends AnyRef
   Definition Classes
     Calculate
4.  implicit class RichCalculateType extends AnyRef
   Definition Classes
     Calculate
5.  sealed abstract class FreeDefExtractor extends AnyRef
   Definition Classes
     Extractors
6.  case class ReifyAliasAttachment (sym: tools.nsc.Global.Symbol, alias: tools.nsc.Global.TermName) extends Product with Serializable
   Definition Classes
     StdAttachments
7.  case class ReifyBindingAttachment (binding: tools.nsc.Global.Tree) extends Product with Serializable
   Definition Classes
     StdAttachments
8.  class SymbolTable extends AnyRef
   Definition Classes
     SymbolTables

### 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 Quasiquotes.UnapplyReifier to any2stringadd[Quasiquotes.UnapplyReifier] performed by method any2stringadd in scala.Predef.
   Definition Classes
     any2stringadd
4.  def ->[B](y: B): (Quasiquotes.UnapplyReifier, B)
   Implicit
     This member is added by an implicit conversion from Quasiquotes.UnapplyReifier to ArrowAssoc[Quasiquotes.UnapplyReifier] performed by method ArrowAssoc in scala.Predef.
   Definition Classes
     ArrowAssoc
   Annotations
     @inline()
5.  final def ==(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
6.  def CannotConvertManifestToTagWithoutScalaReflect(tpe: tools.nsc.Global.Type, manifestInScope: tools.nsc.Global.Tree): Nothing
   Definition Classes
     Errors
7.  def CannotReifyCompoundTypeTreeWithNonEmptyBody(ctt: tools.nsc.Global.CompoundTypeTree): Nothing
   Definition Classes
     Errors
8.  def CannotReifyErroneousPrefix(prefix: tools.nsc.Global.Tree): Nothing
   Definition Classes
     Errors
9.  def CannotReifyErroneousReifee(reifee: Any): Nothing
   Definition Classes
     Errors
10.  def CannotReifyInvalidLazyVal(tree: tools.nsc.Global.ValDef): Nothing
    Definition Classes
      Errors
11.  def CannotReifyRuntimeSplice(tree: tools.nsc.Global.Tree): Nothing
    Definition Classes
      Errors
12.  def CannotReifyType(tpe: tools.nsc.Global.Type): Nothing
    Definition Classes
      Errors
13.  def CannotReifyUntypedPrefix(prefix: tools.nsc.Global.Tree): Nothing
    Definition Classes
      Errors
14.  def CannotReifyUntypedReifee(reifee: Any): Nothing
    Definition Classes
      Errors
15.  def CannotReifyWeakType(details: Any): Nothing
    Definition Classes
      Errors
16.  def action: String
    Definition Classes
      Reifier
17.  final def asInstanceOf[T0]: T0
    Definition Classes
      Any
18.  def boundSymbolsInCallstack: List[tools.nsc.Global.Symbol]
    Definition Classes
      Reify
19.  val calculate: tools.nsc.Global.Traverser { ... /* 2 definitions in type refinement */ }

    Merely traverses the reifiee and records symbols local to the reifee along with their metalevels.

    Merely traverses the reifiee and records symbols local to the reifee along with their metalevels.

    Definition Classes
      Calculate
20.  def call(fname: String, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
21.  def clone(): AnyRef
    Attributes
      protected[java.lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )
22.  val concrete: Boolean
    Definition Classes
      Reifier → Reifier
23.  def current: Any
    Definition Classes
      Reify
24.  def currents: List[Any]
    Definition Classes
      Reify
25.  def defaultErrorPosition: tools.nsc.Global.Position
    Definition Classes
      Errors
26.  def ensureNoExplicitFlags(m: tools.nsc.Global.Modifiers, pos: tools.nsc.Global.Position): Unit
    Definition Classes
      Reifier
27.  def ensuring(cond: (Quasiquotes.UnapplyReifier) ⇒ Boolean, msg: ⇒ Any): Quasiquotes.UnapplyReifier
    Implicit
      This member is added by an implicit conversion from Quasiquotes.UnapplyReifier to Ensuring[Quasiquotes.UnapplyReifier] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
28.  def ensuring(cond: (Quasiquotes.UnapplyReifier) ⇒ Boolean): Quasiquotes.UnapplyReifier
    Implicit
      This member is added by an implicit conversion from Quasiquotes.UnapplyReifier to Ensuring[Quasiquotes.UnapplyReifier] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
29.  def ensuring(cond: Boolean, msg: ⇒ Any): Quasiquotes.UnapplyReifier
    Implicit
      This member is added by an implicit conversion from Quasiquotes.UnapplyReifier to Ensuring[Quasiquotes.UnapplyReifier] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
30.  def ensuring(cond: Boolean): Quasiquotes.UnapplyReifier
    Implicit
      This member is added by an implicit conversion from Quasiquotes.UnapplyReifier to Ensuring[Quasiquotes.UnapplyReifier] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
31.  final def eq(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
32.  def equals(arg0: Any): Boolean
    Definition Classes
      AnyRef → Any
33.  val fillListHole: PartialFunction[Any, tools.nsc.Global.Tree]
    Definition Classes
      Reifier
34.  val fillListOfListsHole: PartialFunction[Any, tools.nsc.Global.Tree]
    Definition Classes
      Reifier
35.  def finalize(): Unit
    Attributes
      protected[java.lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( classOf[java.lang.Throwable] )
36.  def formatted(fmtstr: String): String
    Implicit
      This member is added by an implicit conversion from Quasiquotes.UnapplyReifier to StringFormat[Quasiquotes.UnapplyReifier] performed by method StringFormat in scala.Predef.
    Definition Classes
      StringFormat
    Annotations
      @inline()
37.  final def getClass(): Class[_]
    Definition Classes
      AnyRef → Any
38.  def getReifier: reify.Reifier { val global: UnapplyReifier.this.global.type }
    Definition Classes
      Reifier → Utils
39.  val global: Quasiquotes.global.type
    Definition Classes
      Reifier → Reifier → Utils
40.  def group[T](lst: List[T])(similar: (T, T) ⇒ Boolean): List[List[T]]

    Splits list into a list of groups where subsequent elements are considered similar by the corresponding function.

    Splits list into a list of groups where subsequent elements are considered similar by the corresponding function.

    Example:

    > group(List(1, 1, 0, 0, 1, 0)) { _ == _ } List(List(1, 1), List(0, 0), List(1), List(0))

    Definition Classes
      Reifier
41.  def hasReifier: Boolean
    Definition Classes
      Reifier → Utils
42.  def hashCode(): Int
    Definition Classes
      AnyRef → Any
43.  def holesHaveTypes: Boolean
    Definition Classes
      Reifier
44.  def isCrossStageTypeBearer(tree: tools.nsc.Global.Tree): Boolean
    Definition Classes
      GenUtils
45.  final def isInstanceOf[T0]: Boolean
    Definition Classes
      Any
46.  val isReifyingExpressions: Boolean
    Definition Classes
      Reifier
47.  def isReifyingPatterns: Boolean
    Definition Classes
      Reifier
48.  def isSemiConcreteTypeMember(tpe: tools.nsc.Global.Type): Boolean
    Definition Classes
      GenUtils
49.  val metalevels: tools.nsc.Global.Transformer { ... /* 4 definitions in type refinement */ }

    Makes sense of cross-stage bindings.

    Makes sense of cross-stage bindings.

    Analysis of cross-stage bindings becomes convenient if we introduce the notion of metalevels. Metalevel of a tree is a number that gets incremented every time you reify something and gets decremented when you splice something. Metalevel of a symbol is equal to the metalevel of its definition.

    Example 1. Consider the following snippet:

    reify { val x = 2 // metalevel of symbol x is 1, because it's declared inside reify val y = reify{x} // metalevel of symbol y is 1, because it's declared inside reify // metalevel of Ident(x) is 2, because it's inside two reifies y.splice // metalevel of Ident(y) is 0, because it's inside a designator of a splice }

    Cross-stage bindings are introduced when symbol.metalevel != curr_metalevel. Both bindings introduced in Example 1 are cross-stage.

    Depending on what side of the inequality is greater, the following situations might occur:

    1) symbol.metalevel < curr_metalevel. In this case reifier will generate a free variable that captures both the name of the symbol (to be compiled successfully) and its value (to be run successfully). For example, x in Example 1 will be reified as follows: Ident(newFreeVar("x", IntTpe, x))

    2) symbol.metalevel > curr_metalevel. This leads to a metalevel breach that violates intuitive perception of splicing. As defined in macro spec, splicing takes a tree and inserts it into another tree - as simple as that. However, how exactly do we do that in the case of y.splice? In this very scenario we can use dataflow analysis and inline it, but what if y were a var, and what if it were calculated randomly at runtime?

    This question has a genuinely simple answer. Sure, we cannot resolve such splices statically (i.e. during macro expansion of `reify`), but now we have runtime toolboxes, so noone stops us from picking up that reified tree and evaluating it at runtime (in fact, this is something that `Expr.splice` does transparently).

    This is akin to early vs late binding dilemma. The prior is faster, plus, the latter (implemented with reflection) might not work because of visibility issues or might be not available on all platforms. But the latter still has its uses, so I'm allowing metalevel breaches, but introducing the -Xlog-runtime-evals to log them.

    upd. We no longer do that. In case of a runaway `splice` inside a `reify`, one will get a static error. Why? Unfortunately, the cute idea of transparently converting between static and dynamic splices has failed. 1) Runtime eval that services dynamic splices requires scala-compiler.jar, which might not be on library classpath 2) Runtime eval incurs a severe performance penalty, so it'd better to be explicit about it

    As we can see, the only problem is the fact that lhs'es of `splice` can be code blocks that can capture variables from the outside. Code inside the lhs of an `splice` is not reified, while the code from the enclosing reify is.

    Hence some bindings become cross-stage, which is not bad per se (in fact, some cross-stage bindings have sane semantics, as in the example above). However this affects freevars, since they are delicate inter-dimensional beings that refer to both current and next planes of existence. When splicing tears the fabric of the reality apart, some freevars have to go single-dimensional to retain their sanity.

    Example 2. Consider the following snippet:

    reify { val x = 2 reify{x}.splice }

    Since the result of the inner reify is wrapped in a splice, it won't be reified together with the other parts of the outer reify, but will be inserted into that result verbatim.

    The inner reify produces an Expr[Int] that wraps Ident(freeVar("x", IntTpe, x)). However the freevar the reification points to will vanish when the compiler processes the outer reify. That's why we need to replace that freevar with a regular symbol that will point to reified x.

    Example 3. Consider the following fragment:

    reify { val x = 2 val y = reify{x} y.splice }

    In this case the inner reify doesn't appear next to splice, so it will be reified together with x. This means that no special processing is needed here.

    Example 4. Consider the following fragment:

    reify { val x = 2 { val y = 2 val z = reify{reify{x + y}} z.splice }.splice }

    The reasoning from Example 2 still holds here - we do need to inline the freevar that refers to x. However, we must not touch anything inside the splice'd block, because it's not getting reified.

    Definition Classes
      Metalevels
50.  val mirror: tools.nsc.Global.EmptyTree.type
    Definition Classes
      Reifier → Reifier
51.  def mirrorBuildCall(name: tools.nsc.Global.TermName, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree
    Definition Classes
      Reifier → GenUtils
52.  def mirrorCall(name: tools.nsc.Global.TermName, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree
    Definition Classes
      Reifier → GenUtils
53.  def mirrorFactoryCall(prefix: tools.nsc.Global.TermName, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
54.  def mirrorFactoryCall(value: Product, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
55.  def mirrorMirrorCall(name: tools.nsc.Global.TermName, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
56.  def mirrorMirrorSelect(name: tools.nsc.Global.TermName): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
57.  def mirrorSelect(name: String): tools.nsc.Global.Tree
    Definition Classes
      Reifier → GenUtils
58.  def mirrorSelect(name: tools.nsc.Global.TermName): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
59.  def mkList(args: List[tools.nsc.Global.Tree]): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
60.  def mkListMap(args: List[tools.nsc.Global.Tree]): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
61.  lazy val mkReificationPipeline: (tools.nsc.Global.Tree) ⇒ tools.nsc.Global.Tree
    Definition Classes
      Phases
62.  val nameMap: Map[tools.nsc.Global.Name, Set[tools.nsc.Global.TermName]]

    Map that stores freshly generated names linked to the corresponding names in the reified tree.

    Map that stores freshly generated names linked to the corresponding names in the reified tree. This information is used to reify names created by calls to freshTermName and freshTypeName.

    Definition Classes
      Reifier
63.  final def ne(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
64.  val nonOverloadedExplicitFlags: Long
    Definition Classes
      Reifier
65.  final def notify(): Unit
    Definition Classes
      AnyRef
66.  final def notifyAll(): Unit
    Definition Classes
      AnyRef
67.  def origin(sym: tools.nsc.Global.Symbol): String
    Definition Classes
      GenUtils
68.  def path(fullname: String, mkName: (String) ⇒ tools.nsc.Global.Name): tools.nsc.Global.Tree

    An (unreified) path that refers to definition with given fully qualified name

    An (unreified) path that refers to definition with given fully qualified name

    mkName

      Creator for last portion of name (either TermName or TypeName)

    Definition Classes
      GenUtils
69.  val reifee: tools.nsc.Global.EmptyTree.type
    Definition Classes
      Reifier → Reifier
70.  lazy val reification: tools.nsc.Global.Tree

    For `reifee` and other reification parameters, generate a tree of the form

    For `reifee` and other reification parameters, generate a tree of the form

        {
          val $u: universe.type = <[ universe ]>
          val $m: $u.Mirror = <[ mirror ]>
          $u.Expr[T](rtree)       // if data is a Tree
          $u.TypeTag[T](rtree)    // if data is a Type
        }

    where

    - `universe` is the tree that represents the universe the result will be bound to.
    - `mirror` is the tree that represents the mirror the result will be initially bound to.
    - `rtree` is code that generates `reifee` at runtime.
    - `T` is the type that corresponds to `data`.

    This is not a method, but a value to indicate the fact that Reifier instances are a one-off.

    Definition Classes
      Reifier
71.  def reificationIsConcrete: Boolean

    Keeps track of whether this reification contains abstract type parameters

    Keeps track of whether this reification contains abstract type parameters

    Definition Classes
      GenTypes
72.  lazy val reifier: reify.Reifier { val global: UnapplyReifier.this.global.type }
    Definition Classes
      Utils
73.  def reify(reifee: Any): tools.nsc.Global.Tree

    Reifies any supported value.

    Reifies any supported value. For internal use only, use `reified` instead.

    Definition Classes
      Reify
74.  def reifyAnnotList(annots: List[tools.nsc.Global.Tree]): tools.nsc.Global.Tree
    Definition Classes
      Reifier
75.  def reifyAnnotation(hole: Quasiquotes.Hole): tools.nsc.Global.Tree
    Definition Classes
      Reifier
76.  def reifyAnnotationInfo(ann: tools.nsc.Global.AnnotationInfo): tools.nsc.Global.Tree
    Definition Classes
      GenAnnotationInfos
77.  def reifyBinding(tree: tools.nsc.Global.Tree): tools.nsc.Global.Tree
    Definition Classes
      StdAttachments
78.  def reifyBuildCall(name: tools.nsc.Global.TermName, args: Any*): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
79.  def reifyConstructionCheck(name: tools.nsc.Global.TermName, hole: Quasiquotes.Hole): tools.nsc.Global.Tree
    Definition Classes
      Reifier
80.  val reifyCopypaste: Boolean
    Definition Classes
      Utils
81.  val reifyDebug: Boolean
    Definition Classes
      Utils
82.  def reifyEarlyDef(hole: Quasiquotes.Hole): tools.nsc.Global.Tree
    Definition Classes
      Reifier
83.  def reifyFillingHoles(tree: tools.nsc.Global.Tree): tools.nsc.Global.Tree
    Definition Classes
      Reifier
84.  def reifyFlags(flags: tools.nsc.Global.FlagSet): tools.nsc.Global.Tree
    Definition Classes
      GenTrees
85.  def reifyFreeTerm(binding: tools.nsc.Global.Tree): tools.nsc.Global.Tree
    Definition Classes
      GenSymbols
86.  def reifyFreeType(binding: tools.nsc.Global.Tree): tools.nsc.Global.Tree
    Definition Classes
      GenSymbols
87.  def reifyFunctionType(argtpes: List[tools.nsc.Global.Tree], restpe: tools.nsc.Global.Tree): tools.nsc.Global.Tree
    Definition Classes
      Reifier
88.  def reifyHighRankList(xs: List[Any])(fill: PartialFunction[Any, tools.nsc.Global.Tree])(fallback: (Any) ⇒ tools.nsc.Global.Tree): tools.nsc.Global.Tree

    Reifies list filling all the valid holeMap.

    Reifies list filling all the valid holeMap.

    Reification of non-trivial list is done in two steps:

    1. split the list into groups where every placeholder is always put in a group of its own and all subsequent non-holeMap are grouped together; element is considered to be a placeholder if it's in the domain of the fill function;

    2. fold the groups into a sequence of lists added together with ++ using fill reification for holeMap and fallback reification for non-holeMap.

    Example:

    reifyHighRankList(lst) { // first we define patterns that extract high-rank holeMap (currently ..) case Placeholder(IterableType(_, _)) => tree } { // in the end we define how single elements are reified, typically with default reify call reify(_) }

    Sample execution of previous concrete list reifier:

    > val lst = List(foo, bar, qq$f3948f9s$1) > reifyHighRankList(lst) { ... } { ... } q"List($foo, $bar) ++ ${holeMap(qq$f3948f9s$1).tree}"

    Definition Classes
      UnapplyReifier → Reifier
89.  def reifyList(xs: List[Any]): tools.nsc.Global.Tree

    Reifies arbitrary list filling ..$x and ...$y holeMap when they are put in the correct position.

    Reifies arbitrary list filling ..$x and ...$y holeMap when they are put in the correct position. Falls back to regular reification for zero rank elements.

    Definition Classes
      Reifier → GenUtils
90.  def reifyMirrorObject(x: Product): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
91.  def reifyMirrorObject(name: String): tools.nsc.Global.Tree

    Reify a case object defined in Mirror

    Reify a case object defined in Mirror

    Definition Classes
      GenUtils
92.  def reifyModifiers(m: tools.nsc.Global.Modifiers): tools.nsc.Global.Tree
    Definition Classes
      UnapplyReifier → GenTrees
93.  def reifyName(name: tools.nsc.Global.Name): tools.nsc.Global.Tree
    Definition Classes
      Reifier → GenNames
94.  def reifyPackageStat(hole: Quasiquotes.Hole): tools.nsc.Global.Tree
    Definition Classes
      Reifier
95.  def reifyPosition(pos: tools.nsc.Global.Position): tools.nsc.Global.Tree
    Definition Classes
      GenPositions
96.  def reifyProduct(prefix: String, elements: List[Any]): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
97.  def reifyProduct(x: Product): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
98.  def reifyRefineStat(hole: Quasiquotes.Hole): tools.nsc.Global.Tree
    Definition Classes
      Reifier
99.  def reifySymDef(sym: tools.nsc.Global.Symbol): tools.nsc.Global.Tree
    Definition Classes
      GenSymbols
100.  def reifySymRef(sym: tools.nsc.Global.Symbol): tools.nsc.Global.Tree

     Reify a reference to a symbol

     Reify a reference to a symbol

     Definition Classes
       GenSymbols
101.  val reifyTrace: SimpleTracer
     Definition Classes
       Utils
102.  def reifyTree(tree: tools.nsc.Global.Tree): tools.nsc.Global.Tree

     Reify a tree.

     Reify a tree. For internal use only, use `reified` instead.

     Definition Classes
       Reifier → GenTrees
103.  def reifyTreePlaceholder(tree: tools.nsc.Global.Tree): tools.nsc.Global.Tree
     Definition Classes
       Reifier
104.  def reifyTreeSymbols: Boolean
     Definition Classes
       GenTrees
105.  def reifyTreeSyntactically(tree: tools.nsc.Global.Tree): tools.nsc.Global.Tree
     Definition Classes
       Reifier → GenTrees
106.  def reifyTreeTypes: Boolean
     Definition Classes
       GenTrees
107.  def reifyTuple(args: List[tools.nsc.Global.Tree]): tools.nsc.Global.Tree
     Definition Classes
       Reifier
108.  def reifyTupleType(args: List[tools.nsc.Global.Tree]): tools.nsc.Global.Tree
     Definition Classes
       Reifier
109.  def reifyType(tpe: tools.nsc.Global.Type): tools.nsc.Global.Tree

     Reify a type.

     Reify a type. For internal use only, use `reified` instead.

     Definition Classes
       GenTypes
110.  def reifyVparamss(vparamss: List[List[tools.nsc.Global.ValDef]]): tools.nsc.Global.Tree
     Definition Classes
       Reifier
111.  val reshape: tools.nsc.Global.Transformer { ... /* 2 definitions in type refinement */ }

     Rolls back certain changes that were introduced during typechecking of the reifee.

     Rolls back certain changes that were introduced during typechecking of the reifee.

     These include: * Undoing macro expansions * Replacing type trees with TypeTree(tpe) * Reassembling CompoundTypeTrees into reifiable form * Transforming Modifiers.annotations into Symbol.annotations * Transforming Annotated annotations into AnnotatedType annotations * Transforming Annotated(annot, expr) into Typed(expr, TypeTree(Annotated(annot, _)) * Non-idempotencies of the typechecker: https://github.com/scala/bug/issues/5464

     Definition Classes
       Reshape
112.  def scalaFactoryCall(name: String, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree
     Definition Classes
       Reifier → GenUtils
113.  def scalaFactoryCall(name: tools.nsc.Global.TermName, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree
     Definition Classes
       GenUtils
114.  def spliceType(tpe: tools.nsc.Global.Type): tools.nsc.Global.Tree
     Definition Classes
       GenTypes
115.  val state: State

     Encapsulates reifier state

     Encapsulates reifier state

     When untangling reifier symbol tables from the reifier itself, I discovered that encoding of a symbol table (e.g. producing corresponding reificode) might cause subsequent reification (e.g. when filling in signatures and annotations for syms).

     This is a mess in the face of nested reifications, splices and inlining of thereof, so I made `SymbolTable` immutable, which brought a significant amount of sanity.

     However that wasn't enough. Sure, symbol table became immutable, but the reifier still needed to mutate its `symtab` field during reification. This caused nasty desyncs between the table being encoded and the table of the underlying reifier, so I decided to encapsulate the entire state here, so that encoding can backup the state before it starts and restore it after it completes.

     Definition Classes
       States
116.  def symtab: SymbolTable

     Symbol table of the reifee.

     Symbol table of the reifee.

     Keeps track of auxiliary symbols that are necessary for this reification session. These include: 1) Free vars (terms, types and existentials), 2) Non-locatable symbols (sometimes, e.g. for RefinedTypes, we need to reify these; to do that we create their copies in the reificode) 3) Non-locatable symbols that are referred by #1, #2 and #3

     Exposes three main methods: 1) `syms` that lists symbols belonging to the table, 2) `symXXX` family of methods that provide information about the symbols in the table, 3) `encode` that renders the table into a list of trees (recursively populating #3 and setting up initialization code for #1, #2 and #3)

     Definition Classes
       GenSymbols
117.  final def synchronized[T0](arg0: ⇒ T0): T0
     Definition Classes
       AnyRef
118.  def termPath(fullname: String): tools.nsc.Global.Tree

     An (unreified) path that refers to term definition with given fully qualified name

     An (unreified) path that refers to term definition with given fully qualified name

     Definition Classes
       GenUtils
119.  def toString(): String
     Definition Classes
       AnyRef → Any
120.  lazy val typer: Nothing
     Definition Classes
       Reifier → Reifier → Utils
121.  val universe: tools.nsc.Global.Tree
     Definition Classes
       Reifier → Reifier
122.  final def wait(): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws( ... )
123.  final def wait(arg0: Long, arg1: Int): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws( ... )
124.  final def wait(arg0: Long): Unit
     Definition Classes
       AnyRef
     Annotations
       @throws( ... )
125.  def wrap(tree: tools.nsc.Global.Tree): tools.nsc.Global.Tree

     Wraps expressions into: a block which starts with a sequence of vals that correspond to fresh names that has to be created at evaluation of the quasiquote and ends with reified tree:

     Wraps expressions into: a block which starts with a sequence of vals that correspond to fresh names that has to be created at evaluation of the quasiquote and ends with reified tree:

     { val name$1: universe.TermName = universe.build.freshTermName(prefix1) ... val name$N: universe.TermName = universe.build.freshTermName(prefixN) tree }

     Wraps patterns into: a call into anonymous class' unapply method required by unapply macro expansion:

     new { def unapply(tree) = tree match { case pattern if guard => Some(result) case _ => None } }.unapply(<unapply-selector>)

     where pattern corresponds to reified tree and guard represents conjunction of equalities which check that pairs of names in nameMap.values are equal between each other.

     Definition Classes
       Reifier
126.  def →[B](y: B): (Quasiquotes.UnapplyReifier, B)
     Implicit
       This member is added by an implicit conversion from Quasiquotes.UnapplyReifier to ArrowAssoc[Quasiquotes.UnapplyReifier] performed by method ArrowAssoc in scala.Predef.
     Definition Classes
       ArrowAssoc
127.  object TypedOrAnnotated
     Definition Classes
       GenUtils
128.  object ApplyCall
     Definition Classes
       Extractors
129.  object BoundTerm
     Definition Classes
       Extractors
130.  object BoundType
     Definition Classes
       Extractors
131.  object FreeDef extends Utils.FreeDefExtractor
     Definition Classes
       Extractors
132.  object FreeRef
     Definition Classes
       Extractors
133.  object FreeTermDef extends Utils.FreeDefExtractor
     Definition Classes
       Extractors
134.  object FreeTypeDef extends Utils.FreeDefExtractor
     Definition Classes
       Extractors
135.  object ReifiedTree
     Definition Classes
       Extractors
136.  object ReifiedType
     Definition Classes
       Extractors
137.  object SymDef
     Definition Classes
       Extractors
138.  object TreeSplice
     Definition Classes
       Extractors
139.  object TypeRefToFreeType
     Definition Classes
       Extractors
140.  object reifiedNodeToString extends (tools.nsc.Global.Tree) ⇒ String
     Definition Classes
       NodePrinters
141.  object SymbolTable
     Definition Classes
       SymbolTables

### Inherited from Quasiquotes.Reifier

### Inherited from reify.Reifier

### Inherited from Utils

### Inherited from StdAttachments

### Inherited from SymbolTables

### Inherited from Extractors

### Inherited from NodePrinters

### Inherited from Errors

### Inherited from Phases

### Inherited from Reify

### Inherited from GenUtils

### Inherited from GenPositions

### Inherited from GenAnnotationInfos

### Inherited from GenTrees

### Inherited from GenNames

### Inherited from GenTypes

### Inherited from GenSymbols

### Inherited from Metalevels

### Inherited from Calculate

### Inherited from Reshape

### Inherited from States

### Inherited from AnyRef

### Inherited from Any

### Inherited by implicit conversion any2stringadd from Quasiquotes.UnapplyReifier to any2stringadd[Quasiquotes.UnapplyReifier]

### Inherited by implicit conversion StringFormat from Quasiquotes.UnapplyReifier to StringFormat[Quasiquotes.UnapplyReifier]

### Inherited by implicit conversion Ensuring from Quasiquotes.UnapplyReifier to Ensuring[Quasiquotes.UnapplyReifier]

### Inherited by implicit conversion ArrowAssoc from Quasiquotes.UnapplyReifier to ArrowAssoc[Quasiquotes.UnapplyReifier]

### Ungrouped