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, 6 insertions, 2 deletions

diff --git a/src/compiler/scala/tools/reflect/FastTrack.scala b/src/compiler/scala/tools/reflect/FastTrack.scala
index 5a0ff4f6db..ad1d4c896b 100644
--- a/src/compiler/scala/tools/reflect/FastTrack.scala
+++ b/src/compiler/scala/tools/reflect/FastTrack.scala
@@ -5,7 +5,7 @@ import scala.reflect.reify.Taggers
 import scala.tools.nsc.typechecker.{ Analyzer, Macros }
 import scala.reflect.runtime.Macros.currentMirror
 import scala.reflect.api.Universe
-import scala.reflect.macros.compiler.DefaultMacroCompiler
+import scala.tools.reflect.quasiquotes.{ Quasiquotes => QuasiquoteImpls }
 
 /** Optimizes system macro expansions by hardwiring them directly to their implementations
  *  bypassing standard reflective load and invoke to avoid the overhead of Java/Scala reflection.
@@ -22,6 +22,8 @@ trait FastTrack {
     new { val c: c0.type = c0 } with Taggers
   private implicit def context2macroimplementations(c0: MacroContext): MacroImplementations { val c: c0.type } =
     new { val c: c0.type = c0 } with MacroImplementations
+  private implicit def context2quasiquote(c0: MacroContext): QuasiquoteImpls { val c: c0.type } =
+    new { val c: c0.type = c0 } with QuasiquoteImpls
   private def make(sym: Symbol)(pf: PartialFunction[Applied, MacroContext => Tree]) =
     sym -> new FastTrackEntry(pf)
 
@@ -41,6 +43,8 @@ trait FastTrack {
     make(         materializeTypeTag) { case Applied(_, ttag :: Nil, (u :: _) :: _)     => _.materializeTypeTag(u, EmptyTree, ttag.tpe, concrete = true) },
     make(           ApiUniverseReify) { case Applied(_, ttag :: Nil, (expr :: _) :: _)  => c => c.materializeExpr(c.prefix.tree, EmptyTree, expr) },
     make(            StringContext_f) { case Applied(Select(Apply(_, ps), _), _, args)  => c => c.macro_StringInterpolation_f(ps, args.flatten, c.expandee.pos) },
-    make(ReflectRuntimeCurrentMirror) { case _                                          => c => currentMirror(c).tree }
+    make(ReflectRuntimeCurrentMirror) { case _                                          => c => currentMirror(c).tree },
+    make(  QuasiquoteClass_api_apply) { case _                                          => _.expandQuasiquote },
+    make(QuasiquoteClass_api_unapply) { case _                                          => _.expandQuasiquote }
   )
 }