trait
Importers extends AnyRef
Concrete Value Members
-
final
def
!=(arg0: AnyRef): Boolean
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
def
+(other: String): String
-
def
->[B](y: B): (Importers, B)
-
final
def
==(arg0: AnyRef): Boolean
-
final
def
==(arg0: Any): Boolean
-
final
def
asInstanceOf[T0]: T0
-
def
clone(): AnyRef
-
def
ensuring(cond: (Importers) ⇒ Boolean, msg: ⇒ Any): Importers
-
-
def
ensuring(cond: Boolean, msg: ⇒ Any): Importers
-
def
ensuring(cond: Boolean): Importers
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(arg0: Any): Boolean
-
def
finalize(): Unit
-
def
formatted(fmtstr: String): String
-
final
def
getClass(): Class[_]
-
def
hashCode(): Int
-
final
def
isInstanceOf[T0]: Boolean
-
final
def
ne(arg0: AnyRef): Boolean
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
def
toString(): String
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
def
→[B](y: B): (Importers, B)
EXPERIMENTAL
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 macroUniverse
or a runtime reflectionUniverse
), but sometimes there is a need to migrate artifacts from oneUniverse
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 usingImporter
s, however, they be imported from one universe into another. For example, to importfoo.bar.Baz
from the sourceUniverse
to the targetUniverse
, an importer will first check whether the entire owner chain exists in the targetUniverse
. 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 targetUniverse
.Since importers match
Symbol
tables of the source and the targetUniverse
s using plain string names, it is programmer's responsibility to make sure that imports don't distort semantics, e.g., thatfoo.bar.Baz
in the sourceUniverse
means the same thatfoo.bar.Baz
does in the targetUniverse
.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: