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.

7 files changed, 792 insertions, 2 deletions

diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
index 321baba562..993f735c72 100644
--- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
@@ -190,6 +190,7 @@ trait ScalaSettings extends AbsScalaSettings
   val Yreifydebug             = BooleanSetting("-Yreify-debug", "Trace reification.")
   val Ytyperdebug             = BooleanSetting("-Ytyper-debug", "Trace all type assignments.")
   val Ypatmatdebug            = BooleanSetting("-Ypatmat-debug", "Trace pattern matching translation.")
+  val Yquasiquotedebug        = BooleanSetting("-Yquasiquote-debug", "Trace quasiquote-related activities.")
 
   /** Groups of Settings.
    */
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 }
   )
 }
diff --git a/src/compiler/scala/tools/reflect/quasiquotes/Holes.scala b/src/compiler/scala/tools/reflect/quasiquotes/Holes.scala
new file mode 100644
index 0000000000..9d171d52d2
--- /dev/null
+++ b/src/compiler/scala/tools/reflect/quasiquotes/Holes.scala
@@ -0,0 +1,187 @@
+package scala.tools.reflect
+package quasiquotes
+
+import scala.collection.{immutable, mutable}
+import scala.reflect.internal.Flags._
+
+class Cardinality private[Cardinality](val value: Int) extends AnyVal {
+  def pred = { assert(value - 1 >= 0); new Cardinality(value - 1) }
+  def succ = new Cardinality(value + 1)
+  override def toString = if (value == 0) "no dots" else "." * (value + 1)
+}
+
+object Cardinality {
+  val NoDot = new Cardinality(0)
+  val DotDot = new Cardinality(1)
+  val DotDotDot = new Cardinality(2)
+  object Dot { def unapply(card: Cardinality) = card != NoDot }
+  def parseDots(part: String) = {
+    if (part.endsWith("...")) (part.stripSuffix("..."), DotDotDot)
+    else if (part.endsWith("..")) (part.stripSuffix(".."), DotDot)
+    else (part, NoDot)
+  }
+}
+
+/** Defines abstractions that provide support for splicing into Scala syntax.
+ */
+trait Holes { self: Quasiquotes =>
+  import global._
+  import Cardinality._
+  import definitions._
+  import universeTypes._
+
+  /** Location characterizes a kind of a non-terminal in Scala syntax where something is going to be spliced.
+   *  A location is typically associated with a type of the things that can be spliced there.
+   *  Associated type might be different from an actual tpe of a splicee due to lifting.
+   *  This is the first pillar of modularity in the quasiquote reifier.
+   */
+  sealed abstract class Location(val tpe: Type)
+  case object UnknownLocation extends Location(NoType)
+  case class TreeLocation(override val tpe: Type) extends Location(tpe)
+  case object NameLocation extends Location(nameType)
+  case object ModsLocation extends Location(modsType)
+  case object FlagsLocation extends Location(flagsType)
+  case object SymbolLocation extends Location(symbolType)
+  case class IterableLocation(card: Cardinality, sublocation: TreeLocation) extends Location(NoType) {
+    override val tpe = {
+      def loop(n: Cardinality, tpe: Type): Type =
+        if (n == NoDot) tpe
+        else appliedType(IterableClass.toType, List(loop(n.pred, tpe)))
+      loop(card, sublocation.tpe)
+    }
+  }
+
+  /** Hole type describes location, cardinality and a pre-reification routine associated with a hole.
+   *  An interesting thing about HoleType is that it can be completely inferred from the type of the splicee.
+   *  This is the second pillar of modularity in the quasiquote reifier.
+   */
+  case class HoleType(preprocessor: Tree => Tree, location: Location, cardinality: Cardinality) {
+    def makeHole(tree: Tree) = Hole(preprocessor(tree), location, cardinality)
+  }
+  object HoleType {
+    def unapply(tpe: Type): Option[HoleType] = tpe match {
+      case NativeType(holeTpe) => Some(holeTpe)
+      case LiftableType(holeTpe) => Some(holeTpe)
+      case IterableTreeType(holeTpe) => Some(holeTpe)
+      case IterableLiftableType(holeTpe) => Some(holeTpe)
+      case _ => None
+    }
+
+    trait HoleTypeExtractor {
+      def unapply(tpe: Type): Option[HoleType] = {
+        for {
+          preprocessor <- this.preprocessor(tpe)
+          location <- this.location(tpe)
+          cardinality <- Some(this.cardinality(tpe))
+        } yield HoleType(preprocessor, location, cardinality)
+      }
+      def preprocessor(tpe: Type): Option[Tree => Tree]
+      def location(tpe: Type): Option[Location]
+      def cardinality(tpe: Type): Cardinality = parseCardinality(tpe)._1
+
+      def lifter(tpe: Type): Option[Tree => Tree] = {
+        val lifterTpe = appliedType(LiftableClass.toType, List(tpe))
+        val lifter = c.inferImplicitValue(lifterTpe, silent = true)
+        if (lifter != EmptyTree) Some(tree => {
+          val lifted = Apply(lifter, List(u, tree))
+          val targetType = Select(u, tpnme.Tree)
+          atPos(tree.pos)(TypeApply(Select(lifted, nme.asInstanceOf_), List(targetType)))
+        }) else None
+      }
+
+      def iterator(tpe: Type)(elementTransform: Tree => Tree): Option[Tree => Tree] = {
+        def reifyIterable(tree: Tree, n: Cardinality): Tree = {
+          def loop(tree: Tree, n: Cardinality) =
+            if (n == NoDot) elementTransform(tree)
+            else {
+              val x: TermName = c.freshName()
+              val wrapped = reifyIterable(Ident(x), n.pred)
+              val xToWrapped = Function(List(ValDef(Modifiers(PARAM), x, TypeTree(), EmptyTree)), wrapped)
+              Select(Apply(Select(tree, nme.map), List(xToWrapped)), nme.toList)
+            }
+          if (tree.tpe != null && (tree.tpe <:< listTreeType || tree.tpe <:< listListTreeType)) tree
+          else atPos(tree.pos)(loop(tree, n))
+        }
+        val (card, elementTpe) = parseCardinality(tpe)
+        if (card != NoDot) Some(reifyIterable(_, card)) else None
+      }
+    }
+
+    object NativeType extends HoleTypeExtractor {
+      def preprocessor(tpe: Type) = Some(identity)
+      def location(tpe: Type) = {
+        if (tpe <:< treeType) Some(TreeLocation(tpe))
+        else if (tpe <:< nameType) Some(NameLocation)
+        else if (tpe <:< modsType) Some(ModsLocation)
+        else if (tpe <:< flagsType) Some(FlagsLocation)
+        else if (tpe <:< symbolType) Some(SymbolLocation)
+        else None
+      }
+    }
+
+    object LiftableType extends HoleTypeExtractor {
+      def preprocessor(tpe: Type) = lifter(tpe)
+      def location(tpe: Type) = Some(TreeLocation(treeType))
+    }
+
+    object IterableTreeType extends HoleTypeExtractor {
+      def preprocessor(tpe: Type) = iterator(tpe)(identity)
+      def location(tpe: Type) = {
+        val (card, elementTpe) = parseCardinality(tpe)
+        if (card != NoDot && elementTpe <:< treeType) Some(IterableLocation(card, TreeLocation(elementTpe)))
+        else None
+      }
+    }
+
+    object IterableLiftableType extends HoleTypeExtractor {
+      def preprocessor(tpe: Type) = {
+        val (_, elementTpe) = parseCardinality(tpe)
+        for {
+          lifter <- this.lifter(elementTpe)
+          iterator <- this.iterator(tpe)(lifter)
+        } yield iterator
+      }
+      def location(tpe: Type) = Some(IterableLocation(cardinality(tpe), TreeLocation(treeType)))
+    }
+  }
+
+  /** Hole encapsulates information about splices in quasiquotes.
+   *  It packs together a cardinality of a splice, a splicee (possibly preprocessed)
+   *  and the description of the location in Scala syntax where the splicee can be spliced.
+   *  This is the third pillar of modularity in the quasiquote reifier.
+   */
+  case class Hole(tree: Tree, location: Location, cardinality: Cardinality)
+
+  object Hole {
+    def apply(splicee: Tree, holeCard: Cardinality): Hole = {
+      if (splicee.tpe == null) return new Hole(splicee, UnknownLocation, holeCard)
+      val (spliceeCard, elementTpe) = parseCardinality(splicee.tpe)
+      def cantSplice() = {
+        val holeCardMsg = if (holeCard != NoDot) s" with $holeCard" else ""
+        val action = "splice " + splicee.tpe + holeCardMsg
+        val suggestCard = holeCard != spliceeCard || holeCard != NoDot
+        val spliceeCardMsg = if (holeCard != spliceeCard && spliceeCard != NoDot) s"using $spliceeCard" else "omitting the dots"
+        val cardSuggestion = if (suggestCard) spliceeCardMsg else ""
+        def canBeLifted(tpe: Type) = HoleType.LiftableType.unapply(tpe).nonEmpty
+        val suggestLifting = (holeCard == NoDot || spliceeCard != NoDot) && !(elementTpe <:< treeType) && !canBeLifted(elementTpe)
+        val liftedTpe = if (holeCard != NoDot) elementTpe else splicee.tpe
+        val liftSuggestion = if (suggestLifting) s"providing an implicit instance of Liftable[$liftedTpe]" else ""
+        val advice = List(cardSuggestion, liftSuggestion).filter(_ != "").mkString(" or ")
+        c.abort(splicee.pos, s"Can't $action, consider $advice")
+      }
+      val holeTpe = splicee.tpe match {
+        case _ if holeCard != spliceeCard => cantSplice()
+        case HoleType(holeTpe) => holeTpe
+        case _ => cantSplice()
+      }
+      holeTpe.makeHole(splicee)
+    }
+  }
+
+  def parseCardinality(tpe: Type): (Cardinality, Type) = {
+    if (tpe != null && isIterableType(tpe)) {
+      val (card, innerTpe) = parseCardinality(tpe.typeArguments.head)
+      (card.succ, innerTpe)
+    } else (NoDot, tpe)
+  }
+}
\ No newline at end of file
diff --git a/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala b/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala
new file mode 100644
index 0000000000..9a6ba56c18
--- /dev/null
+++ b/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala
@@ -0,0 +1,134 @@
+package scala.tools.reflect
+package quasiquotes
+
+import scala.tools.nsc.ast.parser.{Parsers => ScalaParser}
+import scala.tools.nsc.ast.parser.Tokens._
+import scala.compat.Platform.EOL
+import scala.reflect.internal.util.{BatchSourceFile, SourceFile}
+import scala.collection.mutable.ListBuffer
+
+/** Builds upon the vanilla Scala parser and teams up together with Placeholders.scala to emulate holes.
+ *  A principled solution to splicing into Scala syntax would be a parser that natively supports holes.
+ *  Unfortunately, that's outside of our reach in Scala 2.11, so we have to emulate.
+ */
+trait Parsers { self: Quasiquotes =>
+  import global._
+
+  abstract class Parser extends {
+    val global: self.global.type = self.global
+  } with ScalaParser {
+    /** Wraps given code to obtain a desired parser mode.
+     *  This way we can just re-use standard parser entry point.
+     */
+    def wrapCode(code: String): String =
+      s"object wrapper { self => $EOL $code $EOL }"
+
+    def unwrapTree(wrappedTree: Tree): Tree = {
+      val PackageDef(_, List(ModuleDef(_, _, Template(_, _, _ :: parsed)))) = wrappedTree
+      parsed match {
+        case tree :: Nil => tree
+        case stats :+ tree => Block(stats, tree)
+      }
+    }
+
+    def parse(code: String): Tree = {
+      try {
+        val wrapped = wrapCode(code)
+        debug(s"wrapped code\n=${wrapped}\n")
+        val file = new BatchSourceFile(nme.QUASIQUOTE_FILE, wrapped)
+        val tree = new QuasiquoteParser(file).parse()
+        unwrapTree(tree)
+      } catch {
+        case mi: MalformedInput => c.abort(c.macroApplication.pos, s"syntax error: ${mi.msg}")
+      }
+    }
+
+    class QuasiquoteParser(source0: SourceFile) extends SourceFileParser(source0) {
+      override val treeBuilder = new ParserTreeBuilder {
+        // q"(..$xs)"
+        override def makeTupleTerm(trees: List[Tree], flattenUnary: Boolean): Tree =
+          Apply(Ident(nme.QUASIQUOTE_TUPLE), trees)
+
+        // tq"(..$xs)"
+        override def makeTupleType(trees: List[Tree], flattenUnary: Boolean): Tree =
+          AppliedTypeTree(Ident(tpnme.QUASIQUOTE_TUPLE), trees)
+
+        // q"{ $x }"
+        override def makeBlock(stats: List[Tree]): Tree = stats match {
+          case (head @ Ident(name)) :: Nil if holeMap.contains(name) => Block(Nil, head)
+          case _ => super.makeBlock(stats)
+        }
+      }
+      import treeBuilder.{global => _, _}
+
+      // q"def foo($x)"
+      override def allowTypelessParams = true
+
+      // q"foo match { case $x }"
+      override def caseClause(): CaseDef =
+        if (isHole && lookingAhead { in.token == CASE || in.token == RBRACE || in.token == SEMI }) {
+          val c = makeCaseDef(Apply(Ident(nme.QUASIQUOTE_CASE), List(Ident(ident()))), EmptyTree, EmptyTree)
+          while (in.token == SEMI) in.nextToken()
+          c
+        } else
+          super.caseClause()
+
+      def isHole = isIdent && holeMap.contains(in.name)
+
+      override def isAnnotation: Boolean =  super.isAnnotation || (isHole && lookingAhead { isAnnotation })
+
+      override def isModifier: Boolean = super.isModifier || (isHole && lookingAhead { isModifier })
+
+      override def isLocalModifier: Boolean = super.isLocalModifier || (isHole && lookingAhead { isLocalModifier })
+
+      override def isTemplateIntro: Boolean = super.isTemplateIntro || (isHole && lookingAhead { isTemplateIntro })
+
+      override def isDclIntro: Boolean = super.isDclIntro || (isHole && lookingAhead { isDclIntro })
+
+      // $mods def foo
+      // $mods T
+      override def readAnnots(annot: => Tree): List[Tree] = in.token match {
+        case AT =>
+          in.nextToken()
+          annot :: readAnnots(annot)
+        case _ if isHole && lookingAhead { in.token == AT || isModifier || isDefIntro || isIdent} =>
+          val ann = Apply(Select(New(Ident(tpnme.QUASIQUOTE_MODS)), nme.CONSTRUCTOR), List(Literal(Constant(in.name.toString))))
+          in.nextToken()
+          ann :: readAnnots(annot)
+        case _ =>
+          Nil
+      }
+    }
+  }
+
+  object TermParser extends Parser
+
+  object CaseParser extends Parser {
+    override def wrapCode(code: String) = super.wrapCode("something match { case " + code + " }")
+
+    override def unwrapTree(wrappedTree: Tree): Tree = {
+      val Match(_, head :: tail) = super.unwrapTree(wrappedTree)
+      if (tail.nonEmpty)
+        c.abort(c.macroApplication.pos, "Can't parse more than one casedef, consider generating a match tree instead")
+      head
+    }
+  }
+
+  object PatternParser extends Parser {
+    override def wrapCode(code: String) = super.wrapCode("something match { case " + code + " => }")
+
+    override def unwrapTree(wrappedTree: Tree): Tree = {
+      val Match(_, List(CaseDef(pat, _, _))) = super.unwrapTree(wrappedTree)
+      pat
+    }
+  }
+
+  object TypeParser extends Parser {
+    override def wrapCode(code: String) = super.wrapCode("type T = " + code)
+
+    override def unwrapTree(wrappedTree: Tree): Tree = {
+      val TypeDef(_, _, _, rhs) = super.unwrapTree(wrappedTree)
+      rhs
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/compiler/scala/tools/reflect/quasiquotes/Placeholders.scala b/src/compiler/scala/tools/reflect/quasiquotes/Placeholders.scala
new file mode 100644
index 0000000000..b680c25f76
--- /dev/null
+++ b/src/compiler/scala/tools/reflect/quasiquotes/Placeholders.scala
@@ -0,0 +1,123 @@
+package scala.tools.reflect
+package quasiquotes
+
+import java.util.UUID.randomUUID
+import scala.collection.{immutable, mutable}
+
+/** Emulates hole support (see Holes.scala) in the quasiquote parser (see Parsers.scala).
+ *  A principled solution to splicing into Scala syntax would be a parser that natively supports holes.
+ *  Unfortunately, that's outside of our reach in Scala 2.11, so we have to emulate.
+ *  This trait stores knowledge of how to represent the holes as something understandable by the parser
+ *  and how to recover holes from the results of parsing the produced representation.
+ */
+trait Placeholders { self: Quasiquotes =>
+  import global._
+  import Cardinality._
+
+  // Step 1: Transform Scala source with holes into vanilla Scala source
+
+  lazy val holeMap = new HoleMap()
+  lazy val code = {
+    val sb = new StringBuilder()
+    val sessionSuffix = randomUUID().toString.replace("-", "").substring(0, 8) + "$"
+
+    foreach2(args, parts.init) { (tree, p) =>
+      val (part, cardinality) = parseDots(p)
+      val placeholderName = c.freshName(TermName(nme.QUASIQUOTE_PREFIX + sessionSuffix))
+      sb.append(part)
+      sb.append(placeholderName)
+      holeMap(placeholderName) = Hole(tree, cardinality)
+    }
+    sb.append(parts.last)
+
+    sb.toString
+  }
+
+  class HoleMap {
+    private val underlying = mutable.ListMap[String, Hole]()
+    private val accessed = mutable.Set[String]()
+    def unused: Set[Name] = (underlying.keys.toSet -- accessed).map(TermName(_))
+    def contains(key: Name) = underlying.contains(key.toString)
+    def apply(key: Name) = {
+      val s = key.toString
+      accessed += s
+      underlying(s)
+    }
+    def update(key: Name, hole: Hole) = {
+      underlying += key.toString -> hole
+    }
+    def get(key: Name) = {
+      val s = key.toString
+      accessed += s
+      underlying.get(s)
+    }
+  }
+
+  // Step 2: Transform vanilla Scala AST into an AST with holes
+
+  trait HolePlaceholder {
+    def matching: PartialFunction[Any, Name]
+    def unapply(scrutinee: Any): Option[(Tree, Location, Cardinality)] = {
+      val name = matching.lift(scrutinee)
+      name.flatMap { holeMap.get(_).map { case Hole(repr, loc, card) => (repr, loc, card) } }
+    }
+  }
+
+  object Placeholder extends HolePlaceholder {
+    def matching = {
+      case name: Name => name
+      case Ident(name) => name
+      case Bind(name, Ident(nme.WILDCARD)) => name
+      case TypeDef(_, name, List(), TypeBoundsTree(EmptyTree, EmptyTree)) => name
+      case ValDef(_, name, TypeTree(), EmptyTree) => name
+    }
+  }
+
+  object ModsPlaceholder extends HolePlaceholder {
+    def matching = {
+      case Apply(Select(New(Ident(tpnme.QUASIQUOTE_MODS)), nme.CONSTRUCTOR), List(Literal(Constant(s: String)))) => TermName(s)
+    }
+  }
+
+  object AnnotPlaceholder {
+    def unapply(tree: Tree): Option[(Tree, Location, Cardinality, List[Tree])] = tree match {
+      case Apply(Select(New(Placeholder(tree, loc, card)), nme.CONSTRUCTOR), args) => Some(tree, loc, card, args)
+      case _ => None
+    }
+  }
+
+  object TuplePlaceholder {
+    def unapply(tree: Tree): Option[List[Tree]] = tree match {
+      case Apply(Ident(nme.QUASIQUOTE_TUPLE), args) => Some(args)
+      case _ => None
+    }
+  }
+
+  object TupleTypePlaceholder {
+    def unapply(tree: Tree): Option[List[Tree]] = tree match {
+      case AppliedTypeTree(Ident(tpnme.QUASIQUOTE_TUPLE), args) => Some(args)
+      case _ => None
+    }
+  }
+
+  object SymbolPlaceholder {
+    def unapply(scrutinee: Any): Option[Tree] = scrutinee match {
+      case Placeholder(tree, SymbolLocation, _) => Some(tree)
+      case _ => None
+    }
+  }
+
+  object CasePlaceholder {
+    def unapply(tree: Tree): Option[(Tree, Location, Cardinality)] = tree match {
+      case CaseDef(Apply(Ident(nme.QUASIQUOTE_CASE), List(Placeholder(tree, location, card))), EmptyTree, EmptyTree) => Some((tree, location, card))
+      case _ => None
+    }
+  }
+
+  object ClassPlaceholder {
+    def unapply(tree: Tree): Option[Tree] = tree match {
+      case ClassDef(_, _, _, _) => Some(tree)
+      case _ => None
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/compiler/scala/tools/reflect/quasiquotes/Quasiquotes.scala b/src/compiler/scala/tools/reflect/quasiquotes/Quasiquotes.scala
new file mode 100644
index 0000000000..fe954e0bfd
--- /dev/null
+++ b/src/compiler/scala/tools/reflect/quasiquotes/Quasiquotes.scala
@@ -0,0 +1,51 @@
+package scala.tools.reflect
+package quasiquotes
+
+import scala.reflect.macros.runtime.Context
+
+abstract class Quasiquotes extends Parsers
+                              with Holes
+                              with Placeholders
+                              with Reifiers {
+  val c: Context
+  val global: c.universe.type = c.universe
+  import c.universe._
+
+  def debug(msg: String): Unit =
+    if (settings.Yquasiquotedebug.value) println(msg)
+
+  lazy val (universe: Tree, args, parts, parse, reify) = c.macroApplication match {
+    case Apply(Select(Select(Apply(Select(universe0, _), List(Apply(_, parts0))), interpolator0), method0), args0) =>
+      val parts1 = parts0.map {
+        case Literal(Constant(s: String)) => s
+        case part => c.abort(part.pos, "Quasiquotes can only be used with literal strings")
+      }
+      val reify0 = method0 match {
+        case nme.apply   => new ApplyReifier().reifyFillingHoles(_)
+        case nme.unapply => new UnapplyReifier().reifyFillingHoles(_)
+        case other       => global.abort(s"Unknown quasiquote api method: $other")
+      }
+      val parse0 = interpolator0 match {
+        case nme.q       => TermParser.parse(_)
+        case nme.tq      => TypeParser.parse(_)
+        case nme.cq      => CaseParser.parse(_)
+        case nme.pq      => PatternParser.parse(_)
+        case other       => global.abort(s"Unknown quasiquote flavor: $other")
+      }
+      (universe0, args0, parts1, parse0, reify0)
+    case _ =>
+      global.abort(s"Couldn't parse call prefix tree ${c.macroApplication}.")
+  }
+
+  lazy val u = universe // shortcut
+  lazy val universeTypes = new definitions.UniverseDependentTypes(universe)
+
+  def expandQuasiquote = {
+    debug(s"\ncode to parse=\n$code\n")
+    val tree = parse(code)
+    debug(s"parsed tree\n=${tree}\n=${showRaw(tree)}\n")
+    val reified = reify(tree)
+    debug(s"reified tree\n=${reified}\n=${showRaw(reified)}\n")
+    reified
+  }
+}
diff --git a/src/compiler/scala/tools/reflect/quasiquotes/Reifiers.scala b/src/compiler/scala/tools/reflect/quasiquotes/Reifiers.scala
new file mode 100644
index 0000000000..ec113036a3
--- /dev/null
+++ b/src/compiler/scala/tools/reflect/quasiquotes/Reifiers.scala
@@ -0,0 +1,290 @@
+package scala.tools.reflect
+package quasiquotes
+
+import java.lang.UnsupportedOperationException
+import scala.reflect.reify.{Reifier => ReflectReifier}
+import scala.reflect.internal.Flags._
+
+trait Reifiers { self: Quasiquotes =>
+  import global._
+  import global.build.SyntacticClassDef
+  import global.treeInfo._
+  import global.definitions._
+  import Cardinality._
+  import universeTypes._
+
+  abstract class Reifier extends {
+    val global: self.global.type = self.global
+  } with ReflectReifier {
+    val reifee     = EmptyTree
+    val universe   = self.universe
+    val mirror     = EmptyTree
+    val concrete   = false
+    lazy val typer = throw new UnsupportedOperationException
+
+    def isReifyingExpressions: Boolean
+    def isReifyingPatterns: Boolean = !isReifyingExpressions
+    def action = if (isReifyingExpressions) "splice" else "extract"
+    def holesHaveTypes = isReifyingExpressions
+
+    def reifyFillingHoles(tree: Tree): Tree = {
+      val reified = reifyTree(tree)
+      holeMap.unused.foreach { hole =>
+        c.abort(holeMap(hole).tree.pos, s"Don't know how to $action here")
+      }
+      reified
+    }
+
+    override def reifyTree(tree: Tree): Tree = {
+      val reified =
+        reifyTreePlaceholder(tree) orElse
+        reifyTreeSyntactically(tree)
+      //println(s"reified ${showRaw(tree)} as $reified")
+      reified
+    }
+
+    def reifyTreePlaceholder(tree: Tree): Tree = tree match {
+      case Placeholder(tree, TreeLocation(_), _) if isReifyingExpressions => tree
+      case Placeholder(tree, _, NoDot) if isReifyingPatterns => tree
+      case Placeholder(tree, _, card @ Dot()) => c.abort(tree.pos, s"Can't $action with $card here")
+      case TuplePlaceholder(args) => reifyTuple(args)
+      case TupleTypePlaceholder(args) => reifyTupleType(args)
+      case CasePlaceholder(tree, location, _) => reifyCase(tree, location)
+      case ClassPlaceholder(tree) => reifyClass(tree)
+      case _ => EmptyTree
+    }
+
+    override def reifyName(name: Name): Tree = name match {
+      case Placeholder(tree, location, _) =>
+        if (holesHaveTypes && !(location.tpe <:< nameType)) c.abort(tree.pos, s"$nameType expected but ${location.tpe} found")
+        tree
+      case _ =>
+        super.reifyName(name)
+    }
+
+    def reifyCase(tree: Tree, location: Location) = {
+      if (holesHaveTypes && !(location.tpe <:< caseDefType)) c.abort(tree.pos, s"$caseDefType expected but ${location.tpe} found")
+      tree
+    }
+
+    def reifyTuple(args: List[Tree]) = args match {
+      case Nil => reify(Literal(Constant(())))
+      case List(hole @ Placeholder(_, _, NoDot)) => reify(hole)
+      case List(Placeholder(_, _, _)) => reifyBuildCall(nme.TupleN, args)
+      // in a case we only have one element tuple without
+      // any cardinality annotations this means that this is
+      // just an expression wrapped in parentheses
+      case List(other) => reify(other)
+      case _ => reifyBuildCall(nme.TupleN, args)
+    }
+
+    def reifyTupleType(args: List[Tree]) = args match {
+      case Nil => reify(Select(Ident(nme.scala_), tpnme.Unit))
+      case List(hole @ Placeholder(_, _, NoDot)) => reify(hole)
+      case List(Placeholder(_, _, _)) => reifyBuildCall(nme.TupleTypeN, args)
+      case List(other) => reify(other)
+      case _ => reifyBuildCall(nme.TupleTypeN, args)
+    }
+
+    def reifyClass(tree: Tree) = {
+      val SyntacticClassDef(mods, name, tparams, constrmods, argss, parents, selfval, body) = tree
+      reifyBuildCall(nme.SyntacticClassDef, mods, name, tparams, constrmods, argss, parents, selfval, body)
+    }
+
+    /** 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))
+     *
+     */
+    def group[T](lst: List[T])(similar: (T, T) => Boolean) = lst.foldLeft[List[List[T]]](List()) {
+      case (Nil, el) => List(List(el))
+      case (ll :+ (last @ (lastinit :+ lastel)), el) if similar(lastel, el) => ll :+ (last :+ el)
+      case (ll, el) => ll :+ List(el)
+    }
+
+    /** 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 it's own and all subsquent 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:
+     *
+     *    reifyMultiCardinalityList(lst) {
+     *      // first we define patterns that extract high-cardinality holeMap (currently ..)
+     *      case Placeholder(CorrespondsTo(tree, tpe)) if tpe <:< iterableTreeType => 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)
+     *    > reifyMultiCardinalityList(lst) { ... } { ... }
+     *    q"List($foo, $bar) ++ ${holeMap(qq$f3948f9s$1).tree}"
+     */
+    def reifyMultiCardinalityList[T](xs: List[T])(fill: PartialFunction[T, Tree])(fallback: T => Tree): Tree
+
+    /** Reifies arbitrary list filling ..$x and ...$y holeMap when they are put
+     *  in the correct position. Fallbacks to regular reification for non-high cardinality
+     *  elements.
+     */
+    override def reifyList(xs: List[Any]): Tree = reifyMultiCardinalityList(xs) {
+      case Placeholder(tree, _, DotDot) => tree
+      case CasePlaceholder(tree, _, DotDot) => tree
+      case List(Placeholder(tree, _, DotDotDot)) => tree
+    } {
+      reify(_)
+    }
+
+    def reifyAnnotList(annots: List[Tree]): Tree
+
+    def ensureNoExplicitFlags(m: Modifiers, pos: Position) =
+      if ((m.flags & ExplicitFlags) != 0L) c.abort(pos, s"Can't $action modifiers together with flags, consider merging flags into modifiers")
+
+    override def mirrorSelect(name: String): Tree =
+      Select(universe, TermName(name))
+
+    override def mirrorCall(name: TermName, args: Tree*): Tree =
+      Apply(Select(universe, name), args.toList)
+
+    override def mirrorBuildCall(name: TermName, args: Tree*): Tree =
+      Apply(Select(Select(universe, nme.build), name), args.toList)
+  }
+
+  class ApplyReifier extends Reifier {
+    def isReifyingExpressions = true
+
+    override def reifyTreeSyntactically(tree: Tree): Tree = tree match {
+      case Block(stats, p @ Placeholder(_, _, _)) => reifyBuildCall(nme.Block, stats :+ p)
+      case Apply(f, List(Placeholder(argss, _, DotDotDot))) => reifyCallWithArgss(f, argss)
+      case RefTree(qual, SymbolPlaceholder(tree)) => mirrorBuildCall(nme.RefTree, reify(qual), tree)
+      case _ => super.reifyTreeSyntactically(tree)
+    }
+
+    def reifyCallWithArgss(f: Tree, argss: Tree) = {
+      val f1 = reifyTree(f)
+      val foldLeftF1 = Apply(TypeApply(Select(argss, nme.foldLeft), List(Select(u, tpnme.Tree))), List(f1))
+      val uDotApply = Function(
+        List(gen.mkSyntheticParam(nme.x_1), gen.mkSyntheticParam(nme.x_2)),
+        Apply(Select(u, nme.Apply), List(Ident(nme.x_1), Ident(nme.x_2))))
+      Apply(foldLeftF1, List(uDotApply))
+    }
+
+    override def reifyMultiCardinalityList[T](xs: List[T])(fill: PartialFunction[T, Tree])(fallback: T => Tree): Tree = xs match {
+      case Nil => mkList(Nil)
+      case _ =>
+        def reifyGroup(group: List[T]): Tree = group match {
+          case List(elem) if fill.isDefinedAt(elem) => fill(elem)
+          case elems => mkList(elems.map(fallback))
+        }
+        val head :: tail = group(xs) { (a, b) => !fill.isDefinedAt(a) && !fill.isDefinedAt(b) }
+        tail.foldLeft[Tree](reifyGroup(head)) { (tree, lst) => Apply(Select(tree, nme.PLUSPLUS), List(reifyGroup(lst))) }
+    }
+
+    override def reifyAnnotList(annots: List[Tree]): Tree = reifyMultiCardinalityList(annots) {
+      case AnnotPlaceholder(tree, _, DotDot, args) =>
+        val x: TermName = c.freshName()
+        val xToAnnotationCtor = Function(
+          List(ValDef(Modifiers(PARAM), x, TypeTree(), EmptyTree)),
+          mirrorBuildCall(nme.mkAnnotationCtor, Ident(x), reify(args)))
+        Apply(Select(tree, nme.map), List(xToAnnotationCtor))
+    } {
+      case AnnotPlaceholder(tree, _: TreeLocation, _, args) =>
+        mirrorBuildCall(nme.mkAnnotationCtor, tree, reify(args))
+      case other => reify(other)
+    }
+
+    override def reifyModifiers(m: Modifiers) = {
+      val (modsPlaceholders, annots) = m.annotations.partition {
+        case ModsPlaceholder(_, _, _) => true
+        case _ => false
+      }
+      val (mods, flags) = modsPlaceholders.map {
+        case ModsPlaceholder(tree, location, card) => (tree, location)
+      }.partition { case (tree, location) =>
+        location match {
+          case ModsLocation => true
+          case FlagsLocation => false
+          case _ => c.abort(tree.pos, s"$flagsType or $modsType expected but ${tree.tpe} found")
+        }
+      }
+      mods match {
+        case (tree, _) :: Nil =>
+          if (flags.nonEmpty) c.abort(flags(0)._1.pos, "Can't splice flags together with modifiers, consider merging flags into modifiers")
+          if (annots.nonEmpty) c.abort(tree.pos, "Can't splice modifiers together with annotations, consider merging annotations into modifiers")
+          ensureNoExplicitFlags(m, tree.pos)
+          tree
+        case _ :: (second, _) :: Nil =>
+          c.abort(second.pos, "Can't splice multiple modifiers, consider merging them into a single modifiers instance")
+        case _ =>
+          val baseFlags = reifyBuildCall(nme.flagsFromBits, m.flags)
+          val reifiedFlags = flags.foldLeft[Tree](baseFlags) { case (flag, (tree, _)) => Apply(Select(flag, nme.OR), List(tree)) }
+          mirrorFactoryCall(nme.Modifiers, reifiedFlags, reify(m.privateWithin), reifyAnnotList(annots))
+      }
+    }
+  }
+
+  class UnapplyReifier extends Reifier {
+    def isReifyingExpressions = false
+
+    override def reifyTreeSyntactically(tree: Tree): Tree = tree match {
+      case treeInfo.Applied(fun, Nil, argss) if fun != tree && !tree.isInstanceOf[AppliedTypeTree] =>
+        reifyBuildCall(nme.Applied, fun, argss)
+      case treeInfo.Applied(fun, targs, argss) if fun != tree & !tree.isInstanceOf[AppliedTypeTree] =>
+        mirrorBuildCall(nme.Applied, reifyBuildCall(nme.TypeApplied, fun, targs), reifyList(argss))
+      case _ =>
+        super.reifyTreeSyntactically(tree)
+    }
+
+    override def scalaFactoryCall(name: String, args: Tree*): Tree =
+      call("scala." + name, args: _*)
+
+    override def reifyMultiCardinalityList[T](xs: List[T])(fill: PartialFunction[T, Tree])(fallback: T => Tree) = xs match {
+      case init :+ last if fill.isDefinedAt(last) =>
+        init.foldRight[Tree](fill(last)) { (el, rest) =>
+          val cons = Select(Select(Select(Ident(nme.scala_), nme.collection), nme.immutable), nme.CONS)
+          Apply(cons, List(fallback(el), rest))
+        }
+      case _ =>
+        mkList(xs.map(fallback))
+    }
+
+    override def reifyAnnotList(annots: List[Tree]): Tree = reifyMultiCardinalityList(annots) {
+      case AnnotPlaceholder(tree, _, DotDot, Nil) => tree
+    } {
+      case AnnotPlaceholder(tree, _, NoDot, Nil) => tree
+      case AnnotPlaceholder(tree, _, NoDot, args) =>
+        val selectCONSTRUCTOR = Apply(Select(u, nme.Select), List(Apply(Select(u, nme.New), List(tree)), Select(Select(u, nme.nmeNme), nme.nmeCONSTRUCTOR)))
+        Apply(Select(u, nme.Apply), List(selectCONSTRUCTOR, reify(args)))
+      case other =>
+        reify(other)
+    }
+
+    override def reifyModifiers(m: Modifiers) = {
+      val mods = m.annotations.collect { case ModsPlaceholder(tree, _, _) => tree }
+      mods match {
+        case tree :: Nil =>
+          if (m.annotations.length != 1) c.abort(tree.pos, "Can't extract modifiers together with annotations, consider extracting just modifiers")
+          ensureNoExplicitFlags(m, tree.pos)
+          tree
+        case _ :: second :: rest =>
+          c.abort(second.pos, "Can't extract multiple modifiers together, consider extracting a single modifiers instance")
+        case Nil =>
+          mirrorFactoryCall(nme.Modifiers, reifyBuildCall(nme.FlagsAsBits, m.flags),
+                                           reify(m.privateWithin), reifyAnnotList(m.annotations))
+      }
+    }
+  }
+}
\ No newline at end of file