implements quasiquotes

- Additions to the reflection API:

  - The Quasiquotes implicit class that defines `q`, `tq`, `pq` and `cq`
    interpolators which now become a part of the `scala.reflect.api.
    Universe`.

  - Implementations of the interpolators are macro-based
    and are hardwired through `FastTrack`.

  - The `Liftable` class and the `StandardLiftables` slice of the cake
    that provide a type class and a bunch of its instances that allow
    to easily splice user-defined types into quasiquotes.

  - Additional methods in `BuildUtils` that are used by the quasiquote
    macro to generate trees, notably:

    - `SyntacticClassDef`. An extractor/constructor that allows to
      construct and deconstruct classes using arguments that mirror
      syntactic form of ClassDefs (e.g. constructor outside of the
      body).

    - `TupleN`, `TupleTypeN`. Extractor/constructor for easy
      construction of ast that represents a tuple term or type
      with given amount of elements.

- Actual implementation of quasiquotes in the `scala.tools.reflect.
  quasiquotes` package which is organized into a cake called
  `Quasiquotes` with slices introducing core abstractions necessary to
  splice into Scala syntax, routines for interfacing with the parser,
  and customized reifiers for tree construction and deconstruction.

1 files changed, 36 insertions, 0 deletions

diff --git a/src/reflect/scala/reflect/api/StandardLiftables.scala b/src/reflect/scala/reflect/api/StandardLiftables.scala
new file mode 100644
index 0000000000..ecea550225
--- /dev/null
+++ b/src/reflect/scala/reflect/api/StandardLiftables.scala
@@ -0,0 +1,36 @@
+package scala.reflect
+package api
+
+trait StandardLiftables { self: Universe =>
+
+  private def requireSameUniverse[T](universe: Universe, tp: String, value: T) =
+    require(universe eq self, s"Can't lift $tp ${showRaw(value)} from universe ${showRaw(universe)} using lift$tp defined for ${showRaw(self)}.")
+
+  implicit def liftExpr[T <: Expr[_]]: Liftable[T] = new Liftable[T] {
+    def apply(universe: Universe, value: T): universe.Tree = {
+      requireSameUniverse(universe, "Expr", value)
+      value.tree.asInstanceOf[universe.Tree]
+    }
+  }
+
+  implicit def liftType[T <: Type]: Liftable[T] = new Liftable[T] {
+    def apply(universe: Universe, value: T): universe.Tree = {
+      requireSameUniverse(universe, "Type", value)
+      universe.TypeTree(value.asInstanceOf[universe.Type])
+    }
+  }
+
+  implicit def liftTypeTag[T <: WeakTypeTag[_]]: Liftable[T] = new Liftable[T] {
+    def apply(universe: Universe, value: T): universe.Tree = {
+      requireSameUniverse(universe, "TypeTag", value)
+      universe.TypeTree(value.asInstanceOf[universe.WeakTypeTag[_]].tpe)
+    }
+  }
+
+  implicit def liftConstant[T <: Constant]: Liftable[T] = new Liftable[T] {
+    def apply(universe: Universe, value: T): universe.Tree = {
+      requireSameUniverse(universe, "Constant", value)
+      universe.Literal(value.asInstanceOf[universe.Constant])
+    }
+  }
+}