ApplyReifier

class ApplyReifier 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

Alphabetic
By Inheritance

Inherited

ApplyReifier
Reifier
Reifier
Utils
StdAttachments
SymbolTables
Extractors
NodePrinters
Errors
Phases
Reify
GenUtils
GenPositions
GenAnnotationInfos
GenTrees
GenNames
GenTypes
GenSymbols
Metalevels
Calculate
Reshape
States
AnyRef
Any

Implicitly

by any2stringadd
by StringFormat
by Ensuring
by ArrowAssoc

Hide All
Show All

Visibility

Public
All

Instance Constructors

new ApplyReifier()

Type Members

class State extends AnyRef

Definition Classes
States
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
implicit class RichCalculateSymbol extends AnyRef

Definition Classes
Calculate
implicit class RichCalculateType extends AnyRef

Definition Classes
Calculate
sealed abstract class FreeDefExtractor extends AnyRef

Definition Classes
Extractors
case class ReifyAliasAttachment (sym: tools.nsc.Global.Symbol, alias: tools.nsc.Global.TermName) extends Product with Serializable

Definition Classes
StdAttachments
case class ReifyBindingAttachment (binding: tools.nsc.Global.Tree) extends Product with Serializable

Definition Classes
StdAttachments
class SymbolTable extends AnyRef

Definition Classes
SymbolTables

Value Members

final def !=(arg0: Any): Boolean
Test two objects for inequality.
Test two objects for inequality.
returns
true if !(this == that), false otherwise.

Definition Classes
AnyRef → Any
final def ##(): Int
Equivalent to x.hashCode except for boxed numeric types and null.
Equivalent to x.hashCode except for boxed numeric types and null. For numerics, it returns a hash value which is consistent with value equality: if two value type instances compare as true, then ## will produce the same hash value for each of them. For null returns a hashcode where null.hashCode throws a NullPointerException.
returns
a hash value consistent with ==

Definition Classes
AnyRef → Any
def +(other: String): String

Implicit
This member is added by an implicit conversion from Quasiquotes.ApplyReifier to any2stringadd[Quasiquotes.ApplyReifier] performed by method any2stringadd in scala.Predef.
Definition Classes
any2stringadd
def ->[B](y: B): (Quasiquotes.ApplyReifier, B)

Implicit
This member is added by an implicit conversion from Quasiquotes.ApplyReifier to ArrowAssoc[Quasiquotes.ApplyReifier] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
Annotations
@inline()
final def ==(arg0: Any): Boolean
The expression x == that is equivalent to if (x eq null) that eq null else x.equals(that).
The expression x == that is equivalent to if (x eq null) that eq null else x.equals(that).
returns
true if the receiver object is equivalent to the argument; false otherwise.

Definition Classes
AnyRef → Any
def CannotConvertManifestToTagWithoutScalaReflect(tpe: tools.nsc.Global.Type, manifestInScope: tools.nsc.Global.Tree): Nothing

Definition Classes
Errors
def CannotReifyCompoundTypeTreeWithNonEmptyBody(ctt: tools.nsc.Global.CompoundTypeTree): Nothing

Definition Classes
Errors
def CannotReifyErroneousPrefix(prefix: tools.nsc.Global.Tree): Nothing

Definition Classes
Errors
def CannotReifyErroneousReifee(reifee: Any): Nothing

Definition Classes
Errors
def CannotReifyInvalidLazyVal(tree: tools.nsc.Global.ValDef): Nothing

Definition Classes
Errors
def CannotReifyRuntimeSplice(tree: tools.nsc.Global.Tree): Nothing

Definition Classes
Errors
def CannotReifyType(tpe: tools.nsc.Global.Type): Nothing

Definition Classes
Errors
def CannotReifyUntypedPrefix(prefix: tools.nsc.Global.Tree): Nothing

Definition Classes
Errors
def CannotReifyUntypedReifee(reifee: Any): Nothing

Definition Classes
Errors
def CannotReifyWeakType(details: Any): Nothing

Definition Classes
Errors
def action: String

Definition Classes
Reifier
final def asInstanceOf[T0]: T0
Cast the receiver object to be of type T0.
Cast the receiver object to be of type T0.
Note that the success of a cast at runtime is modulo Scala's erasure semantics. Therefore the expression 1.asInstanceOf[String] will throw a ClassCastException at runtime, while the expression List(1).asInstanceOf[List[String]] will not. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the requested type.
returns
the receiver object.

Definition Classes
Any
Exceptions thrown
ClassCastException if the receiver object is not an instance of the erasure of type T0.
def boundSymbolsInCallstack: List[tools.nsc.Global.Symbol]

Definition Classes
Reify
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
def call(fname: String, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree

Definition Classes
GenUtils
def clone(): AnyRef
Create a copy of the receiver object.
Create a copy of the receiver object.
The default implementation of the clone method is platform dependent.
returns
a copy of the receiver object.

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
Note
not specified by SLS as a member of AnyRef
val concrete: Boolean

Definition Classes
Reifier → Reifier
def current: Any

Definition Classes
Reify
def currents: List[Any]

Definition Classes
Reify
def defaultErrorPosition: tools.nsc.Global.Position

Definition Classes
Errors
def ensureNoExplicitFlags(m: tools.nsc.Global.Modifiers, pos: tools.nsc.Global.Position): Unit

Definition Classes
Reifier
def ensuring(cond: (Quasiquotes.ApplyReifier) ⇒ Boolean, msg: ⇒ Any): Quasiquotes.ApplyReifier

Implicit
This member is added by an implicit conversion from Quasiquotes.ApplyReifier to Ensuring[Quasiquotes.ApplyReifier] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: (Quasiquotes.ApplyReifier) ⇒ Boolean): Quasiquotes.ApplyReifier

Implicit
This member is added by an implicit conversion from Quasiquotes.ApplyReifier to Ensuring[Quasiquotes.ApplyReifier] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean, msg: ⇒ Any): Quasiquotes.ApplyReifier

Implicit
This member is added by an implicit conversion from Quasiquotes.ApplyReifier to Ensuring[Quasiquotes.ApplyReifier] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean): Quasiquotes.ApplyReifier

Implicit
This member is added by an implicit conversion from Quasiquotes.ApplyReifier to Ensuring[Quasiquotes.ApplyReifier] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
final def eq(arg0: AnyRef): Boolean
Tests whether the argument (that) is a reference to the receiver object (this).
Tests whether the argument (that) is a reference to the receiver object (this).
The eq method implements an equivalence relation on non-null instances of AnyRef, and has three additional properties:
- It is consistent: for any non-null instances x and y of type AnyRef, multiple invocations of x.eq(y) consistently returns true or consistently returns false.
- For any non-null instance x of type AnyRef, x.eq(null) and null.eq(x) returns false.
- null.eq(null) returns true.
When overriding the equals or hashCode methods, it is important to ensure that their behavior is consistent with reference equality. Therefore, if two objects are references to each other (o1 eq o2), they should be equal to each other (o1 == o2) and they should hash to the same value (o1.hashCode == o2.hashCode).
returns
true if the argument is a reference to the receiver object; false otherwise.

Definition Classes
AnyRef
def equals(arg0: Any): Boolean
The equality method for reference types.
The equality method for reference types. Default implementation delegates to eq.
See also equals in scala.Any.
returns
true if the receiver object is equivalent to the argument; false otherwise.

Definition Classes
AnyRef → Any
val fillListHole: PartialFunction[Any, tools.nsc.Global.Tree]

Definition Classes
Reifier
val fillListOfListsHole: PartialFunction[Any, tools.nsc.Global.Tree]

Definition Classes
Reifier
def finalize(): Unit
Called by the garbage collector on the receiver object when there are no more references to the object.
Called by the garbage collector on the receiver object when there are no more references to the object.
The details of when and if the finalize method is invoked, as well as the interaction between finalize and non-local returns and exceptions, are all platform dependent.

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
Note
not specified by SLS as a member of AnyRef
def formatted(fmtstr: String): String

Implicit
This member is added by an implicit conversion from Quasiquotes.ApplyReifier to StringFormat[Quasiquotes.ApplyReifier] performed by method StringFormat in scala.Predef.
Definition Classes
StringFormat
Annotations
@inline()
final def getClass(): Class[_]
Returns the runtime class representation of the object.
Returns the runtime class representation of the object.
returns
a class object corresponding to the runtime type of the receiver.

Definition Classes
AnyRef → Any
def getReifier: reify.Reifier { val global: ApplyReifier.this.global.type }

Definition Classes
Reifier → Utils
val global: Quasiquotes.global.type

Definition Classes
Reifier → Reifier → Utils
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
def hasReifier: Boolean

Definition Classes
Reifier → Utils
def hashCode(): Int
The hashCode method for reference types.
The hashCode method for reference types. See hashCode in scala.Any.
returns
the hash code value for this object.

Definition Classes
AnyRef → Any
def holesHaveTypes: Boolean

Definition Classes
Reifier
def isCrossStageTypeBearer(tree: tools.nsc.Global.Tree): Boolean

Definition Classes
GenUtils
final def isInstanceOf[T0]: Boolean
Test whether the dynamic type of the receiver object is T0.
Test whether the dynamic type of the receiver object is T0.
Note that the result of the test is modulo Scala's erasure semantics. Therefore the expression 1.isInstanceOf[String] will return false, while the expression List(1).isInstanceOf[List[String]] will return true. In the latter example, because the type argument is erased as part of compilation it is not possible to check whether the contents of the list are of the specified type.
returns
true if the receiver object is an instance of erasure of type T0; false otherwise.

Definition Classes
Any
val isReifyingExpressions: Boolean

Definition Classes
Reifier
def isReifyingPatterns: Boolean

Definition Classes
Reifier
def isSemiConcreteTypeMember(tpe: tools.nsc.Global.Type): Boolean

Definition Classes
GenUtils
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
val mirror: tools.nsc.Global.EmptyTree.type

Definition Classes
Reifier → Reifier
def mirrorBuildCall(name: tools.nsc.Global.TermName, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree

Definition Classes
Reifier → GenUtils
def mirrorCall(name: tools.nsc.Global.TermName, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree

Definition Classes
Reifier → GenUtils
def mirrorFactoryCall(prefix: tools.nsc.Global.TermName, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree

Definition Classes
GenUtils
def mirrorFactoryCall(value: Product, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree

Definition Classes
GenUtils
def mirrorMirrorCall(name: tools.nsc.Global.TermName, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree

Definition Classes
GenUtils
def mirrorMirrorSelect(name: tools.nsc.Global.TermName): tools.nsc.Global.Tree

Definition Classes
GenUtils
def mirrorSelect(name: String): tools.nsc.Global.Tree

Definition Classes
Reifier → GenUtils
def mirrorSelect(name: tools.nsc.Global.TermName): tools.nsc.Global.Tree

Definition Classes
GenUtils
def mkList(args: List[tools.nsc.Global.Tree]): tools.nsc.Global.Tree

Definition Classes
GenUtils
def mkListMap(args: List[tools.nsc.Global.Tree]): tools.nsc.Global.Tree

Definition Classes
GenUtils
lazy val mkReificationPipeline: (tools.nsc.Global.Tree) ⇒ tools.nsc.Global.Tree

Definition Classes
Phases
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
final def ne(arg0: AnyRef): Boolean
Equivalent to !(this eq that).
Equivalent to !(this eq that).
returns
true if the argument is not a reference to the receiver object; false otherwise.

Definition Classes
AnyRef
val nonOverloadedExplicitFlags: Long

Definition Classes
Reifier
final def notify(): Unit
Wakes up a single thread that is waiting on the receiver object's monitor.
Wakes up a single thread that is waiting on the receiver object's monitor.

Definition Classes
AnyRef
Note
not specified by SLS as a member of AnyRef
final def notifyAll(): Unit
Wakes up all threads that are waiting on the receiver object's monitor.
Wakes up all threads that are waiting on the receiver object's monitor.

Definition Classes
AnyRef
Note
not specified by SLS as a member of AnyRef
def origin(sym: tools.nsc.Global.Symbol): String

Definition Classes
GenUtils
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
val reifee: tools.nsc.Global.EmptyTree.type

Definition Classes
Reifier → Reifier
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
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
lazy val reifier: reify.Reifier { val global: ApplyReifier.this.global.type }

Definition Classes
Utils
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
def reifyAnnotList(annots: List[tools.nsc.Global.Tree]): tools.nsc.Global.Tree

Definition Classes
Reifier
def reifyAnnotation(hole: Quasiquotes.Hole): tools.nsc.Global.Tree

Definition Classes
Reifier
def reifyAnnotationInfo(ann: tools.nsc.Global.AnnotationInfo): tools.nsc.Global.Tree

Definition Classes
GenAnnotationInfos
def reifyBinding(tree: tools.nsc.Global.Tree): tools.nsc.Global.Tree

Definition Classes
StdAttachments
def reifyBuildCall(name: tools.nsc.Global.TermName, args: Any*): tools.nsc.Global.Tree

Definition Classes
GenUtils
def reifyConstructionCheck(name: tools.nsc.Global.TermName, hole: Quasiquotes.Hole): tools.nsc.Global.Tree

Definition Classes
Reifier
val reifyCopypaste: Boolean

Definition Classes
Utils
val reifyDebug: Boolean

Definition Classes
Utils
def reifyEarlyDef(hole: Quasiquotes.Hole): tools.nsc.Global.Tree

Definition Classes
Reifier
def reifyFillingHoles(tree: tools.nsc.Global.Tree): tools.nsc.Global.Tree

Definition Classes
Reifier
def reifyFlags(flags: tools.nsc.Global.FlagSet): tools.nsc.Global.Tree

Definition Classes
GenTrees
def reifyFreeTerm(binding: tools.nsc.Global.Tree): tools.nsc.Global.Tree

Definition Classes
GenSymbols
def reifyFreeType(binding: tools.nsc.Global.Tree): tools.nsc.Global.Tree

Definition Classes
GenSymbols
def reifyFunctionType(argtpes: List[tools.nsc.Global.Tree], restpe: tools.nsc.Global.Tree): tools.nsc.Global.Tree

Definition Classes
Reifier
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
ApplyReifier → Reifier
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. Fallbacks to regular reification for zero rank elements.

Definition Classes
Reifier → GenUtils
def reifyMirrorObject(x: Product): tools.nsc.Global.Tree

Definition Classes
GenUtils
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
def reifyModifiers(m: tools.nsc.Global.Modifiers): tools.nsc.Global.Tree

Definition Classes
ApplyReifier → GenTrees
def reifyName(name: tools.nsc.Global.Name): tools.nsc.Global.Tree

Definition Classes
Reifier → GenNames
def reifyPackageStat(hole: Quasiquotes.Hole): tools.nsc.Global.Tree

Definition Classes
Reifier
def reifyPosition(pos: tools.nsc.Global.Position): tools.nsc.Global.Tree

Definition Classes
GenPositions
def reifyProduct(prefix: String, elements: List[Any]): tools.nsc.Global.Tree

Definition Classes
GenUtils
def reifyProduct(x: Product): tools.nsc.Global.Tree

Definition Classes
GenUtils
def reifyRefineStat(hole: Quasiquotes.Hole): tools.nsc.Global.Tree

Definition Classes
Reifier
def reifySymDef(sym: tools.nsc.Global.Symbol): tools.nsc.Global.Tree

Definition Classes
GenSymbols
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
val reifyTrace: SimpleTracer

Definition Classes
Utils
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
def reifyTreePlaceholder(tree: tools.nsc.Global.Tree): tools.nsc.Global.Tree

Definition Classes
Reifier
def reifyTreeSymbols: Boolean

Definition Classes
GenTrees
def reifyTreeSyntactically(tree: tools.nsc.Global.Tree): tools.nsc.Global.Tree

Definition Classes
Reifier → GenTrees
def reifyTreeTypes: Boolean

Definition Classes
GenTrees
def reifyTuple(args: List[tools.nsc.Global.Tree]): tools.nsc.Global.Tree

Definition Classes
Reifier
def reifyTupleType(args: List[tools.nsc.Global.Tree]): tools.nsc.Global.Tree

Definition Classes
Reifier
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
def reifyVparamss(vparamss: List[List[tools.nsc.Global.ValDef]]): tools.nsc.Global.Tree

Definition Classes
Reifier
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://issues.scala-lang.org/browse/SI-5464

Definition Classes
Reshape
def scalaFactoryCall(name: String, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree

Definition Classes
Reifier → GenUtils
def scalaFactoryCall(name: tools.nsc.Global.TermName, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree

Definition Classes
GenUtils
def spliceType(tpe: tools.nsc.Global.Type): tools.nsc.Global.Tree

Definition Classes
GenTypes
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
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
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
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
def toString(): String
Creates a String representation of this object.
Creates a String representation of this object. The default representation is platform dependent. On the java platform it is the concatenation of the class name, "@", and the object's hashcode in hexadecimal.
returns
a String representation of the object.

Definition Classes
AnyRef → Any
lazy val typer: Nothing

Definition Classes
Reifier → Reifier → Utils
val universe: tools.nsc.Global.Tree

Definition Classes
Reifier → Reifier
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( ... )
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
def →[B](y: B): (Quasiquotes.ApplyReifier, B)

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

Definition Classes
GenUtils
object ApplyCall

Definition Classes
Extractors
object BoundTerm

Definition Classes
Extractors
object BoundType

Definition Classes
Extractors
object FreeDef extends Utils.FreeDefExtractor

Definition Classes
Extractors
object FreeRef

Definition Classes
Extractors
object FreeTermDef extends Utils.FreeDefExtractor

Definition Classes
Extractors
object FreeTypeDef extends Utils.FreeDefExtractor

Definition Classes
Extractors
object ReifiedTree

Definition Classes
Extractors
object ReifiedType

Definition Classes
Extractors
object SymDef

Definition Classes
Extractors
object TreeSplice

Definition Classes
Extractors
object TypeRefToFreeType

Definition Classes
Extractors
object reifiedNodeToString extends (tools.nsc.Global.Tree) ⇒ String

Definition Classes
NodePrinters
object SymbolTable

Definition Classes
SymbolTables

Inherited from Quasiquotes.Reifier

Inherited from reify.Reifier

Inherited from Utils

Inherited from StdAttachments

Packages

ApplyReifier

class ApplyReifier extends Quasiquotes.Reifier

Instance Constructors

Type Members

Value Members

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.ApplyReifier to any2stringadd[Quasiquotes.ApplyReifier]

Inherited by implicit conversion StringFormat from Quasiquotes.ApplyReifier to StringFormat[Quasiquotes.ApplyReifier]

Inherited by implicit conversion Ensuring from Quasiquotes.ApplyReifier to Ensuring[Quasiquotes.ApplyReifier]

Inherited by implicit conversion ArrowAssoc from Quasiquotes.ApplyReifier to ArrowAssoc[Quasiquotes.ApplyReifier]

Ungrouped

Packages

ApplyReifier 

class ApplyReifier extends Quasiquotes.Reifier

Instance Constructors

Type Members

Value Members

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.ApplyReifier to any2stringadd[Quasiquotes.ApplyReifier]

Inherited by implicit conversion StringFormat from Quasiquotes.ApplyReifier to StringFormat[Quasiquotes.ApplyReifier]

Inherited by implicit conversion Ensuring from Quasiquotes.ApplyReifier to Ensuring[Quasiquotes.ApplyReifier]

Inherited by implicit conversion ArrowAssoc from Quasiquotes.ApplyReifier to ArrowAssoc[Quasiquotes.ApplyReifier]

Ungrouped

ApplyReifier