Context

Abruptly terminates current macro expansion leaving a note about what happened. Use enclosingPosition if you're in doubt what position to pass to pos.

Reification prefix that refers to the base reflexive universe, scala.reflect.basis. Providing it for the prefix parameter of reifyTree or reifyType will create a tree that can be inspected at runtime.

A cache shared by all invocations of the same macro within a single compilation run.

This cache is cleared automatically after a compilation run is completed or abandoned. It is also specific to a particular macro definition.

To share data between different macros and/or different compilation runs, use globalCache.

Mark a variable as captured; i.e. force boxing in a *Ref type.

Convert type of a captured variable to *Ref type.

Exposes current compiler settings as a list of options. Use scalac -help, scalac -X and scalac -Y to learn about currently supported options.

Returns a macro definition which triggered this macro expansion.

Exposes current compilation run.

For sending a message which should not be labeled as a warning/error, but also shouldn't require -verbose to be visible. Use enclosingPosition if you're in doubt what position to pass to pos.

Tree that corresponds to the enclosing application, or EmptyTree if not applicable.

Tree that corresponds to the enclosing class, or EmptyTree if not applicable.

Types along with corresponding trees for which implicit arguments are currently searched. Can be useful to get information about an application with an implicit parameter that is materialized during current macro expansion.

Unlike openImplicits, this is a val, which means that it gets initialized when the context is created and always stays the same regardless of whatever happens during macro expansion.

Contexts that represent macros in-flight, including the current one. Very much like a stack trace, but for macros only. Can be useful for interoperating with other macros and for imposing compiler-friendly limits on macro expansion.

Is also priceless for emitting sane error messages for macros that are called by other macros on synthetic (i.e. position-less) trees. In that dire case navigate the enclosingMacros stack, and it will most likely contain at least one macro with a position-ful macro application. See enclosingPosition for a default implementation of this logic.

Unlike openMacros, this is a val, which means that it gets initialized when the context is created and always stays the same regardless of whatever happens during macro expansion.

Tree that corresponds to the enclosing method, or EmptyTree if not applicable.

Tries to guess a position for the enclosing application. But that is simple, right? Just dereference pos of macroApplication? Not really. If we're in a synthetic macro expansion (no positions), we must do our best to infer the position of something that triggerd this expansion. Surprisingly, quite often we can do this by navigation the enclosingMacros stack.

Compilation unit that contains this macro application.

..

Determines whether the compiler expanding a macro is a presentation compiler.

Determines whether the compiler expanding a macro targets JVM.

Determines whether the compiler expanding a macro targets CLR.

Determines whether the compiler expanding a macro is a Scaladoc compiler.

Creates a fresh name from the provided name

Creates a fresh string from the provided string

Creates a fresh string

Exposes means to control the compiler UI

A cache shared by all invocations of all macros across all compilation runs.

Needs to be used with extreme care, since memory leaks here will swiftly crash the presentation compiler. For example, Scala IDE typically launches a compiler run on every edit action so there might be hundreds of runs per minute.

Warnings and errors. Use enclosingPosition if you're in doubt what position to pass to pos.

Infers an implicit value of the expected type pt in the macro callsite context. Optional pos parameter provides a position that will be associated with the implicit search.

If silent is false, TypeError will be thrown in case of an inference error. If silent is true, the typecheck is silent and will return EmptyTree if an error occurs. Such errors don't vanish and can be inspected by turning on -Xlog-implicits. Unlike in typeCheck, silent is true by default.

Infers an implicit view from the provided tree tree from the type from to the type to in the macro callsite context.

Optional pos parameter provides a position that will be associated with the implicit search. Another optional parameter, reportAmbiguous controls whether ambiguous implicit errors should be reported. If we search for a view simply to find out whether one type is coercible to another, it might be desirable to set this flag to false.

If silent is false, TypeError will be thrown in case of an inference error. If silent is true, the typecheck is silent and will return EmptyTree if an error occurs. Such errors don't vanish and can be inspected by turning on -Xlog-implicits. Unlike in typeCheck, silent is true by default.

Informational messages, suppressed unless -verbose or force=true. Use enclosingPosition if you're in doubt what position to pass to pos.

Drops into interactive mode if supported by the compiler UI

Exposes a classloader that corresponds to the library classpath.

With this classloader you can perform on-the-fly evaluation of macro arguments. For example, consider this code snippet:

def staticEval[T](x: T) = macro staticEval[T]

def staticEval[T: c.TypeTag](c: Context)(x: c.Expr[T]) = { import scala.reflect.runtime.{universe => ru} val mirror = ru.runtimeMirror(c.libraryClassLoader) import scala.tools.reflect.ToolBox val toolBox = mirror.mkToolBox() val importer = ru.mkImporter(c.universe).asInstanceOf[ru.Importer { val from: c.universe.type }] val tree = c.resetAllAttrs(x.tree.duplicate) val imported = importer.importTree(tree) val valueOfX = toolBox.runExpr(imported).asInstanceOf[T] ... }

// [Eugene++] using this guy will tremendously slow down the compilation // https://twitter.com/xeno_by/status/201248317831774208 // todo. we need to address this somehow

Exposes library classpath.

The tree that undergoes macro expansion. Can be useful to get an offset or a range position of the entire tree being processed.

Creates a reporter that prints messages to the console according to the settings.

minSeverity determines minimum severity of the messages to be printed. 0 stands for INFO, 1 stands for WARNING and 2 stands for ERROR.

Types along with corresponding trees for which implicit arguments are currently searched. Can be useful to get information about an application with an implicit parameter that is materialized during current macro expansion.

Unlike enclosingImplicits, this is a def, which means that it gets recalculated on every invocation, so it might change depending on what is going on during macro expansion.

Contexts that represent macros in-flight, including the current one. Very much like a stack trace, but for macros only. Can be useful for interoperating with other macros and for imposing compiler-friendly limits on macro expansion.

Is also priceless for emitting sane error messages for macros that are called by other macros on synthetic (i.e. position-less) trees. In that dire case navigate the openMacros stack, and it will most likely contain at least one macro with a position-ful macro application. See enclosingPosition for a default implementation of this logic.

Unlike enclosingMacros, this is a def, which means that it gets recalculated on every invocation, so it might change depending on what is going on during macro expansion.

..

Mark given identifier as a reference to a captured variable itself suppressing dereferencing with the elem field.

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.

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

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 basisUniverse and runtimeUniverse. 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.

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.

Recursively resets symbols and types in a given tree.

Note that this does not revert the tree to its pre-typer shape. For more info, read up https://issues.scala-lang.org/browse/SI-5464.

Recursively resets locally defined symbols and types in a given tree.

Note that this does not revert the tree to its pre-typer shape. For more info, read up https://issues.scala-lang.org/browse/SI-5464.

Reification prefix that refers to the runtime reflexive universe, scala.reflect.runtime.universe. Providing it for the prefix parameter of reifyTree or reifyType will create a full-fledged tree that can be inspected at runtime.

Updates current compiler settings with a list of options. Use scalac -help, scalac -X and scalac -Y to learn about currently supported options.

Updates current compiler settings with an option string. Use scalac -help, scalac -X and scalac -Y to learn about currently supported options. todo. http://groups.google.com/group/scala-internals/browse_thread/thread/07c18cff41f59203

Exposes macro-specific settings as a list of strings. These settings are passed to the compiler via the "-Xmacro-settings:setting1,setting2...,settingN" command-line option.

Typechecks the provided tree against the expected type pt in the macro callsite context.

If silent is false, TypeError will be thrown in case of a typecheck error. If silent is true, the typecheck is silent and will return EmptyTree if an error occurs. Such errors don't vanish and can be inspected by turning on -Ymacro-debug-verbose. Unlike in inferImplicitValue and inferImplicitView, silent is false by default.

Typechecking can be steered with the following optional parameters: withImplicitViewsDisabled recursively prohibits implicit views (though, implicit vals will still be looked up and filled in), default value is false withMacrosDisabled recursively prohibits macro expansions and macro-based implicits, default value is false

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

Temporary sets compiler settings to a given list of options and executes a given closure. Use scalac -help, scalac -X and scalac -Y to learn about currently supported options.

Temporary sets compiler settings to a given option string and executes a given closure. Use scalac -help, scalac -X and scalac -Y to learn about currently supported options.

Test two objects for inequality.

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.

Test two objects for equality. The expression x == that is equivalent to if (x eq null) that eq null else x.equals(that).

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.

Create a copy of the receiver object.

The default implementation of the clone method is platform dependent.

Tests whether the argument (arg0) 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).

The equality method for reference types. Default implementation delegates to eq.

See also equals in Any.

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.

Returns string formatted according to given format string. Format strings are as for String.format (@see java.lang.String.format).

A representation that corresponds to the dynamic class of the receiver object.

The nature of the representation is platform dependent.

The hashCode method for reference types. See hashCode in Any.

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.

Creates a UI-less reporter that simply accumulates all the messages

Equivalent to !(this eq that).

Wakes up a single thread that is waiting on the receiver object's monitor.

Wakes up all threads that are waiting on the receiver object's monitor.

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.