refactors macro compilation

Upgrades the way that macro defs are compiled by factoring out most of
the logic in typedMacroBody and related errors in ContextErrors into an
standalone cake. This leads to tighter cohesion and better code reuse
as the cake is isolated from the rest of the compiler and is much easier
to evolve than just a method body.

Increased convenience of coding macro compilation allowed me to further
clarify the implementation of the macro engine (e.g. take a look at
Validators.scala) and to easily implement additional features, namely:

1) Parameters and return type of macro implementations can now be plain
c.Tree's instead of previously mandatory c.Expr's. This makes macros more
lightweight as there are a lot of situations when one doesn't need to
splice macro params (the only motivation to use exprs over trees). Also
as we're on the verge of having quasiquotes in trunk, there soon will be
no reason to use exprs at all, since quasiquotes can splice everything.

2) Macro implementations can now be defined in bundles, standalone cakes
built around a macro context: http://docs.scala-lang.org/overviews/macros/bundles.html.
This further reduces boilerplate by simplifying implementations complex
macros due to the fact that macro programmers no longer need to play
path-dependent games to use helpers.

19 files changed, 766 insertions, 513 deletions

diff --git a/src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala b/src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala
new file mode 100644
index 0000000000..749e730c0e
--- /dev/null
+++ b/src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala
@@ -0,0 +1,33 @@
+package scala.reflect.macros
+package compiler
+
+import scala.tools.nsc.Global
+import scala.reflect.macros.runtime.Context
+
+abstract class DefaultMacroCompiler extends Resolvers
+                                       with Validators
+                                       with Errors {
+  val global: Global
+  import global._
+
+  val typer: global.analyzer.Typer
+  private implicit val context0 = typer.context
+  val context = typer.context
+
+  val macroDdef: DefDef
+  lazy val macroDef = macroDdef.symbol
+
+  private case class MacroImplResolutionException(pos: Position, msg: String) extends Exception
+  def abort(pos: Position, msg: String) = throw MacroImplResolutionException(pos, msg)
+
+  def resolveMacroImpl: Tree = {
+    try {
+      validateMacroImplRef()
+      macroImplRef
+    } catch {
+      case MacroImplResolutionException(pos, msg) =>
+        context.error(pos, msg)
+        EmptyTree
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/compiler/scala/reflect/macros/compiler/Errors.scala b/src/compiler/scala/reflect/macros/compiler/Errors.scala
new file mode 100644
index 0000000000..dd3142127e
--- /dev/null
+++ b/src/compiler/scala/reflect/macros/compiler/Errors.scala
@@ -0,0 +1,113 @@
+package scala.reflect.macros
+package compiler
+
+import scala.compat.Platform.EOL
+import scala.reflect.macros.util.Traces
+
+trait Errors extends Traces {
+  self: DefaultMacroCompiler =>
+
+  import global._
+  import analyzer._
+  import definitions._
+  import typer.TyperErrorGen._
+  import typer.infer.InferErrorGen._
+  def globalSettings = global.settings
+
+  // sanity check errors
+
+  private def implRefError(message: String) = abort(macroDdef.pos, message)
+
+  def MacroImplReferenceWrongShapeError() = implRefError(
+      "macro implementation reference has wrong shape. required:\n"+
+      "macro [<static object>].<method name>[[<type args>]] or\n" +
+      "macro [<macro bundle>].<method name>[[<type args>]]")
+
+  def MacroImplNotPublicError() = implRefError("macro implementation must be public")
+
+  def MacroImplOverloadedError() = implRefError("macro implementation cannot be overloaded")
+
+  def MacroImplWrongNumberOfTypeArgumentsError() = implRefError(TypedApplyWrongNumberOfTpeParametersErrorMessage(macroImplRef))
+
+  // compatibility errors
+
+  // helpers
+
+  private def lengthMsg(flavor: String, violation: String, extra: Symbol) = {
+    val noun = if (flavor == "value") "parameter" else "type parameter"
+    val message = noun + " lists have different length, " + violation + " extra " + noun
+    val suffix = if (extra ne NoSymbol) " " + extra.defString else ""
+    message + suffix
+  }
+
+  private def abbreviateCoreAliases(s: String): String = List("WeakTypeTag", "Expr").foldLeft(s)((res, x) => res.replace("c.universe." + x, "c." + x))
+
+  private def showMeth(pss: List[List[Symbol]], restpe: Type, abbreviate: Boolean) = {
+    var argsPart = (pss map (ps => ps map (_.defString) mkString ("(", ", ", ")"))).mkString
+    if (abbreviate) argsPart = abbreviateCoreAliases(argsPart)
+    var retPart = restpe.toString
+    if (abbreviate || macroDdef.tpt.tpe == null) retPart = abbreviateCoreAliases(retPart)
+    argsPart + ": " + retPart
+  }
+
+  // not exactly an error generator, but very related
+  // and I dearly wanted to push it away from Macros.scala
+  private def checkConforms(slot: String, rtpe: Type, atpe: Type) = {
+    val verbose = macroDebugVerbose || settings.explaintypes.value
+
+    def check(rtpe: Type, atpe: Type): Boolean = {
+      def success() = { if (verbose) println(rtpe + " <: " + atpe + "?" + EOL + "true"); true }
+      (rtpe, atpe) match {
+        case _ if rtpe eq atpe => success()
+        case (TypeRef(_, RepeatedParamClass, rtpe :: Nil), TypeRef(_, RepeatedParamClass, atpe :: Nil)) => check(rtpe, atpe)
+        case (ExprClassOf(_), TreeType()) => success()
+        case (TreeType(), ExprClassOf(_)) => success()
+        case _ => rtpe <:< atpe
+      }
+    }
+
+    val ok =
+      if (verbose) withTypesExplained(check(rtpe, atpe))
+      else check(rtpe, atpe)
+    if (!ok) {
+      if (!macroDebugVerbose)
+        explainTypes(rtpe, atpe)
+      compatibilityError("type mismatch for %s: %s does not conform to %s".format(slot, abbreviateCoreAliases(rtpe.toString), abbreviateCoreAliases(atpe.toString)))
+    }
+  }
+
+  private def compatibilityError(message: String) =
+    implRefError(
+      "macro implementation has wrong shape:"+
+      "\n required: " + showMeth(rparamss, rret, abbreviate = true) +
+      "\n found   : " + showMeth(aparamss, aret, abbreviate = false) +
+      "\n" + message)
+
+  def MacroImplNonTagImplicitParameters(params: List[Symbol]) = compatibilityError("macro implementations cannot have implicit parameters other than WeakTypeTag evidences")
+
+  def MacroImplParamssMismatchError() = compatibilityError("number of parameter sections differ")
+
+  def MacroImplExtraParamsError(aparams: List[Symbol], rparams: List[Symbol]) = compatibilityError(lengthMsg("value", "found", aparams(rparams.length)))
+
+  def MacroImplMissingParamsError(aparams: List[Symbol], rparams: List[Symbol]) = compatibilityError(abbreviateCoreAliases(lengthMsg("value", "required", rparams(aparams.length))))
+
+  def checkMacroImplParamTypeMismatch(atpe: Type, rparam: Symbol) = checkConforms("parameter " + rparam.name, rparam.tpe, atpe)
+
+  def checkMacroImplResultTypeMismatch(atpe: Type, rret: Type) = checkConforms("return type", atpe, rret)
+
+  def MacroImplParamNameMismatchError(aparam: Symbol, rparam: Symbol) = compatibilityError("parameter names differ: " + rparam.name + " != " + aparam.name)
+
+  def MacroImplVarargMismatchError(aparam: Symbol, rparam: Symbol) = {
+    def fail(paramName: Name) = compatibilityError("types incompatible for parameter " + paramName + ": corresponding is not a vararg parameter")
+    if (isRepeated(rparam) && !isRepeated(aparam)) fail(rparam.name)
+    if (!isRepeated(rparam) && isRepeated(aparam)) fail(aparam.name)
+  }
+
+  def MacroImplTargMismatchError(atargs: List[Type], atparams: List[Symbol]) =
+    compatibilityError(NotWithinBoundsErrorMessage("", atargs, atparams, macroDebugVerbose || settings.explaintypes.value))
+
+  def MacroImplTparamInstantiationError(atparams: List[Symbol], ex: NoInstance) =
+    compatibilityError(
+      "type parameters "+(atparams map (_.defString) mkString ", ")+" cannot be instantiated\n"+
+      ex.getMessage)
+}
\ No newline at end of file
diff --git a/src/compiler/scala/reflect/macros/compiler/Resolvers.scala b/src/compiler/scala/reflect/macros/compiler/Resolvers.scala
new file mode 100644
index 0000000000..3025eb52a1
--- /dev/null
+++ b/src/compiler/scala/reflect/macros/compiler/Resolvers.scala
@@ -0,0 +1,91 @@
+package scala.reflect.macros
+package compiler
+
+import scala.reflect.internal.Flags._
+import scala.reflect.macros.TypecheckException
+
+trait Resolvers {
+  self: DefaultMacroCompiler =>
+
+  import global._
+  import analyzer._
+  import definitions._
+  import treeInfo._
+  import gen._
+
+  /** Determines the type of context implied by the macro def.
+   */
+  val ctxTpe = MacroContextClass.tpe
+
+  /** Resolves a macro impl reference provided in the right-hand side of the given macro definition.
+   *
+   *  Acceptable shapes of the right-hand side:
+   *    1) [<static object>].<method name>[[<type args>]] // vanilla macro def
+   *    2) [<macro bundle>].<method name>[[<type args>]]  // shiny new macro bundle
+   *
+   *  Produces a tree, which represents a reference to a macro implementation if everything goes well,
+   *  otherwise reports found errors and returns EmptyTree. The resulting tree should have the following format:
+   *
+   *    qualifier.method[targs]
+   *
+   *  Qualifier here might be omitted (local macro defs), be a static object (vanilla macro defs)
+   *  or be a dummy instance of a macro bundle (e.g. new MyMacro(???).expand).
+   */
+  lazy val macroImplRef: Tree = {
+    val (maybeBundleRef, methName, targs) = macroDdef.rhs match {
+      case Applied(methRef @ Select(bundleRef @ RefTree(qual, bundleName), methName), targs, Nil) =>
+        (RefTree(qual, bundleName.toTypeName), methName, targs)
+      case Applied(Ident(methName), targs, Nil) =>
+        (Ident(context.owner.enclClass), methName, targs)
+      case _ =>
+        (EmptyTree, TermName(""), Nil)
+    }
+
+    val untypedImplRef = typer.silent(_.typedType(maybeBundleRef)) match {
+      case SilentResultValue(result) if isMacroBundleType(result.tpe) =>
+        val bundleClass = result.tpe.typeSymbol
+        if (!bundleClass.owner.isPackageClass) abort(macroDef.pos, "macro bundles can only be defined as top-level classes or traits")
+
+        // synthesize the invoker, i.e. given a top-level `trait Foo extends Macro { def expand = ... } `
+        // create a top-level definition `class FooInvoker(val c: Context) extends Foo` in MACRO_INVOKER_PACKAGE
+        val invokerPid = gen.mkUnattributedRef(nme.MACRO_INVOKER_PACKAGE)
+        val invokerName = TypeName(bundleClass.fullName.split('.').map(_.capitalize).mkString("") + nme.MACRO_INVOKER_SUFFIX)
+        val invokerFullName = TypeName(s"$invokerPid.$invokerName")
+        val existingInvoker = rootMirror.getClassIfDefined(invokerFullName)
+        if (!currentRun.compiles(existingInvoker)) {
+          def mkContextValDef(flags: Long) = ValDef(Modifiers(flags), nme.c, TypeTree(ctxTpe), EmptyTree)
+          val contextField = mkContextValDef(PARAMACCESSOR)
+          val contextParam = mkContextValDef(PARAM | PARAMACCESSOR)
+          val invokerCtor = DefDef(Modifiers(), nme.CONSTRUCTOR, Nil, List(List(contextParam)), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(()))))
+          val invoker = atPos(bundleClass.pos)(ClassDef(NoMods, invokerName, Nil, Template(List(Ident(bundleClass)), emptyValDef, List(contextField, invokerCtor))))
+          currentRun.compileLate(PackageDef(invokerPid, List(invoker)))
+        }
+
+        // synthesize the macro impl reference, which is going to look like:
+        // `new Foo$invoker(???).expand` plus the optional type arguments
+        val instanceOfInvoker = New(Select(invokerPid, invokerName), List(List(Select(scalaDot(nme.Predef), nme.???))))
+        gen.mkTypeApply(Select(instanceOfInvoker, methName), targs)
+      case _ =>
+        macroDdef.rhs
+    }
+
+    val typedImplRef = typer.silent(_.typed(markMacroImplRef(untypedImplRef)), reportAmbiguousErrors = false)
+    typedImplRef match {
+      case SilentResultValue(success) => success
+      case SilentTypeError(err) => abort(err.errPos, err.errMsg)
+    }
+  }
+
+  // FIXME: cannot write this concisely because of SI-7507
+  // lazy val (isImplBundle, macroImplOwner, macroImpl, macroImplTargs) =
+  private lazy val dissectedMacroImplRef =
+    macroImplRef match {
+      case MacroImplReference(isBundle, owner, meth, targs) => (isBundle, owner, meth, targs)
+      case _ => MacroImplReferenceWrongShapeError()
+    }
+  lazy val isImplBundle = dissectedMacroImplRef._1
+  lazy val isImplMethod = !isImplBundle
+  lazy val macroImplOwner = dissectedMacroImplRef._2
+  lazy val macroImpl = dissectedMacroImplRef._3
+  lazy val targs = dissectedMacroImplRef._4
+}
diff --git a/src/compiler/scala/reflect/macros/compiler/Validators.scala b/src/compiler/scala/reflect/macros/compiler/Validators.scala
new file mode 100644
index 0000000000..60cfc94a23
--- /dev/null
+++ b/src/compiler/scala/reflect/macros/compiler/Validators.scala
@@ -0,0 +1,193 @@
+package scala.reflect.macros
+package compiler
+
+import java.util.UUID.randomUUID
+import scala.reflect.internal.Flags._
+import scala.reflect.macros.TypecheckException
+
+trait Validators {
+  self: DefaultMacroCompiler =>
+
+  import global._
+  import analyzer._
+  import definitions._
+  import treeInfo._
+  import typer.infer._
+
+  def validateMacroImplRef() = {
+    sanityCheck()
+    if (macroImpl != Predef_???) checkMacroDefMacroImplCorrespondence()
+  }
+
+  private def sanityCheck() = {
+    if (!macroImpl.isMethod) MacroImplReferenceWrongShapeError()
+    if (!macroImpl.isPublic) MacroImplNotPublicError()
+    if (macroImpl.isOverloaded) MacroImplOverloadedError()
+    if (macroImpl.typeParams.length != targs.length) MacroImplWrongNumberOfTypeArgumentsError()
+    val declaredInStaticObject = isImplMethod && (macroImplOwner.isStaticOwner || macroImplOwner.moduleClass.isStaticOwner)
+    val declaredInTopLevelClass = isImplBundle && macroImplOwner.owner.isPackageClass
+    if (!declaredInStaticObject && !declaredInTopLevelClass) MacroImplReferenceWrongShapeError()
+  }
+
+  private def checkMacroDefMacroImplCorrespondence() = {
+    val atvars = atparams map freshVar
+    def atpeToRtpe(atpe: Type) = atpe.substSym(aparamss.flatten, rparamss.flatten).instantiateTypeParams(atparams, atvars)
+
+    // we only check strict correspondence between value parameterss
+    // type parameters of macro defs and macro impls don't have to coincide with each other
+    val implicitParams = aparamss.flatten filter (_.isImplicit)
+    if (implicitParams.nonEmpty) MacroImplNonTagImplicitParameters(implicitParams)
+    if (aparamss.length != rparamss.length) MacroImplParamssMismatchError()
+    map2(aparamss, rparamss)((aparams, rparams) => {
+      if (aparams.length < rparams.length) MacroImplMissingParamsError(aparams, rparams)
+      if (rparams.length < aparams.length) MacroImplExtraParamsError(aparams, rparams)
+    })
+
+    try {
+      // cannot fuse this map2 and the map2 above because if aparamss.flatten != rparamss.flatten
+      // then `atpeToRtpe` is going to fail with an unsound substitution
+      map2(aparamss.flatten, rparamss.flatten)((aparam, rparam) => {
+        if (aparam.name != rparam.name && !rparam.isSynthetic) MacroImplParamNameMismatchError(aparam, rparam)
+        if (isRepeated(aparam) ^ isRepeated(rparam)) MacroImplVarargMismatchError(aparam, rparam)
+        val aparamtpe = aparam.tpe.dealias match {
+          case RefinedType(List(tpe), Scope(sym)) if tpe =:= ctxTpe && sym.allOverriddenSymbols.contains(MacroContextPrefixType) => tpe
+          case tpe => tpe
+        }
+        checkMacroImplParamTypeMismatch(atpeToRtpe(aparamtpe), rparam)
+      })
+
+      checkMacroImplResultTypeMismatch(atpeToRtpe(aret), rret)
+
+      val maxLubDepth = lubDepth(aparamss.flatten map (_.tpe)) max lubDepth(rparamss.flatten map (_.tpe))
+      val atargs = solvedTypes(atvars, atparams, atparams map varianceInType(aret), upper = false, depth = maxLubDepth)
+      val boundsOk = typer.silent(_.infer.checkBounds(macroDdef, NoPrefix, NoSymbol, atparams, atargs, ""))
+      boundsOk match {
+        case SilentResultValue(true) => // do nothing, success
+        case SilentResultValue(false) | SilentTypeError(_) => MacroImplTargMismatchError(atargs, atparams)
+      }
+    } catch {
+      case ex: NoInstance => MacroImplTparamInstantiationError(atparams, ex)
+    }
+  }
+
+  // aXXX (e.g. aparamss) => characteristics of the actual macro impl signature extracted from the macro impl ("a" stands for "actual")
+  // rXXX (e.g. rparamss) => characteristics of the reference macro impl signature synthesized from the macro def ("r" stands for "reference")
+  // FIXME: cannot write this concisely because of SI-7507
+  //lazy val MacroImplSig(atparams, aparamss, aret) = macroImplSig
+  //lazy val MacroImplSig(_, rparamss, rret) = referenceMacroImplSig
+  lazy val atparams = macroImplSig.tparams
+  lazy val aparamss = macroImplSig.paramss
+  lazy val aret = macroImplSig.ret
+  lazy val rparamss = referenceMacroImplSig.paramss
+  lazy val rret = referenceMacroImplSig.ret
+
+  // Technically this can be just an alias to MethodType, but promoting it to a first-class entity
+  // provides better encapsulation and convenient syntax for pattern matching.
+  private case class MacroImplSig(tparams: List[Symbol], paramss: List[List[Symbol]], ret: Type)
+
+  /** An actual macro implementation signature extracted from a macro implementation method.
+   *
+   *  For the following macro impl:
+   *    def fooBar[T: c.WeakTypeTag]
+   *           (c: scala.reflect.macros.Context)
+   *           (xs: c.Expr[List[T]])
+   *           : c.Expr[T] = ...
+   *
+   *  This function will return:
+   *    (c: scala.reflect.macros.Context)(xs: c.Expr[List[T]])c.Expr[T]
+   *
+   *  Note that type tag evidence parameters are not included into the result.
+   *  Type tag context bounds for macro impl tparams are optional.
+   *  Therefore compatibility checks ignore such parameters, and we don't need to bother about them here.
+   *
+   *  This method cannot be reduced to just macroImpl.info, because macro implementations might
+   *  come in different shapes. If the implementation is an apply method of a Macro-compatible object,
+   *  then it won't have (c: Context) in its parameters, but will rather refer to Macro.c.
+   *
+   *  @param macroImpl The macro implementation symbol
+   */
+  private lazy val macroImplSig: MacroImplSig = {
+    val tparams = macroImpl.typeParams
+    val paramss = transformTypeTagEvidenceParams(macroImplRef, (param, tparam) => NoSymbol)
+    val ret = macroImpl.info.finalResultType
+    MacroImplSig(tparams, paramss, ret)
+  }
+
+  /** A reference macro implementation signature extracted from a given macro definition.
+   *
+   *  For the following macro def:
+   *    def foo[T](xs: List[T]): T = macro fooBar
+   *
+   *  This function will return:
+   *    (c: scala.reflect.macros.Context)(xs: c.Expr[List[T]])c.Expr[T]
+   *
+   *  Note that type tag evidence parameters are not included into the result.
+   *  Type tag context bounds for macro impl tparams are optional.
+   *  Therefore compatibility checks ignore such parameters, and we don't need to bother about them here.
+   *
+   *  Also note that we need a DefDef, not the corresponding MethodSymbol, because that symbol would be of no use for us.
+   *  Macro signatures are verified when typechecking macro defs, which means that at that moment inspecting macroDef.info
+   *  means asking for cyclic reference errors.
+   *
+   *  We need macro implementation symbol as well, because the return type of the macro definition might be omitted,
+   *  and in that case we'd need to infer it from the return type of the macro implementation. Luckily for us, we can
+   *  use that symbol without a risk of running into cycles.
+   *
+   *  @param typer     Typechecker of `macroDdef`
+   *  @param macroDdef The macro definition tree
+   *  @param macroImpl The macro implementation symbol
+   */
+  private lazy val referenceMacroImplSig: MacroImplSig = {
+    // had to move method's body to an object because of the recursive dependencies between sigma and param
+    object SigGenerator {
+      val cache = scala.collection.mutable.Map[Symbol, Symbol]()
+      val ctxPrefix =
+        if (isImplMethod) singleType(NoPrefix, makeParam(nme.macroContext, macroDdef.pos, ctxTpe, SYNTHETIC))
+        else singleType(ThisType(macroImpl.owner), macroImpl.owner.tpe.member(nme.c))
+      var paramss =
+        if (isImplMethod) List(ctxPrefix.termSymbol) :: mmap(macroDdef.vparamss)(param)
+        else mmap(macroDdef.vparamss)(param)
+      val macroDefRet =
+        if (!macroDdef.tpt.isEmpty) typer.typedType(macroDdef.tpt).tpe
+        else computeMacroDefTypeFromMacroImplRef(macroDdef, macroImplRef)
+      val implReturnType = sigma(increaseMetalevel(ctxPrefix, macroDefRet))
+
+      object SigmaTypeMap extends TypeMap {
+        def mapPrefix(pre: Type) = pre match {
+          case ThisType(sym) if sym == macroDef.owner =>
+            singleType(singleType(ctxPrefix, MacroContextPrefix), ExprValue)
+          case SingleType(NoPrefix, sym) =>
+            mfind(macroDdef.vparamss)(_.symbol == sym).fold(pre)(p => singleType(singleType(NoPrefix, param(p)), ExprValue))
+          case _ =>
+            mapOver(pre)
+        }
+        def apply(tp: Type): Type = tp match {
+          case TypeRef(pre, sym, args) =>
+            val pre1  = mapPrefix(pre)
+            val args1 = mapOverArgs(args, sym.typeParams)
+            if ((pre eq pre1) && (args eq args1)) tp
+            else typeRef(pre1, sym, args1)
+          case _ =>
+            mapOver(tp)
+        }
+      }
+      def sigma(tpe: Type): Type = SigmaTypeMap(tpe)
+
+      def makeParam(name: Name, pos: Position, tpe: Type, flags: Long) =
+        macroDef.newValueParameter(name.toTermName, pos, flags) setInfo tpe
+      def param(tree: Tree): Symbol = (
+        cache.getOrElseUpdate(tree.symbol, {
+          val sym = tree.symbol
+          assert(sym.isTerm, s"sym = $sym, tree = $tree")
+          makeParam(sym.name, sym.pos, sigma(increaseMetalevel(ctxPrefix, sym.tpe)), sym.flags)
+        })
+      )
+    }
+
+    import SigGenerator._
+    macroLogVerbose(s"generating macroImplSigs for: $macroDdef")
+    val result = MacroImplSig(macroDdef.tparams map (_.symbol), paramss, implReturnType)
+    macroLogVerbose(s"result is: $result")
+    result
+  }
+}
diff --git a/src/compiler/scala/reflect/macros/runtime/Synthetics.scala b/src/compiler/scala/reflect/macros/runtime/Synthetics.scala
index 73f3ab8d20..1156769a80 100644
--- a/src/compiler/scala/reflect/macros/runtime/Synthetics.scala
+++ b/src/compiler/scala/reflect/macros/runtime/Synthetics.scala
@@ -5,7 +5,6 @@
 package scala.reflect.macros
 package runtime
 
-import java.util.UUID._
 import scala.reflect.internal.Flags._
 import scala.reflect.internal.util.BatchSourceFile
 import scala.reflect.io.VirtualFile
@@ -42,11 +41,6 @@ trait Synthetics {
     else EmptyTree
   }
 
-  // TODO: provide a way to specify a pretty name for debugging purposes
-  private def randomFileName() = (
-    "macroSynthetic-" + randomUUID().toString.replace("-", "") + ".scala"
-  )
-
   def introduceTopLevel[T: PackageSpec](packagePrototype: T, definition: universe.ImplDef): RefTree =
     introduceTopLevel(packagePrototype, List(definition)).head
 
@@ -55,18 +49,7 @@ trait Synthetics {
 
   private def introduceTopLevel[T: PackageSpec](packagePrototype: T, definitions: List[universe.ImplDef]): List[RefTree] = {
     val code @ PackageDef(pid, _) = implicitly[PackageSpec[T]].mkPackageDef(packagePrototype, definitions)
-    val syntheticFileName = randomFileName()
-    // compatibility with SBT
-    // on the one hand, we need to specify some jfile here, otherwise sbt crashes with an NPE (SI-6870)
-    // on the other hand, we can't specify the obvious enclosingUnit, because then sbt somehow fails to run tests using type macros
-    // okay, now let's specify a guaranteedly non-existent file in an existing directory (so that we don't run into permission problems)
-    val relatedJfile = enclosingUnit.source.file.file
-    val fakeJfile = if (relatedJfile != null) new java.io.File(relatedJfile.getParent, syntheticFileName) else null
-    val virtualFile = new VirtualFile(syntheticFileName) { override def file = fakeJfile }
-    val sourceFile = new BatchSourceFile(virtualFile, code.toString)
-    val unit = new CompilationUnit(sourceFile)
-    unit.body = code
-    universe.currentRun.compileLate(unit)
+    universe.currentRun.compileLate(code)
     definitions map (definition => Select(pid, definition.name))
   }
 
diff --git a/src/compiler/scala/reflect/macros/util/Helpers.scala b/src/compiler/scala/reflect/macros/util/Helpers.scala
new file mode 100644
index 0000000000..ada8efa833
--- /dev/null
+++ b/src/compiler/scala/reflect/macros/util/Helpers.scala
@@ -0,0 +1,71 @@
+package scala.reflect.macros
+package util
+
+import scala.tools.nsc.typechecker.Analyzer
+
+trait Helpers {
+  self: Analyzer =>
+
+  import global._
+  import definitions._
+
+  /** Transforms parameters lists of a macro impl.
+   *  The `transform` function is invoked only for WeakTypeTag evidence parameters.
+   *
+   *  The transformer takes two arguments: a value parameter from the parameter list
+   *  and a type parameter that is witnesses by the value parameter.
+   *
+   *  If the transformer returns a NoSymbol, the value parameter is not included from the result.
+   *  If the transformer returns something else, this something else is included in the result instead of the value parameter.
+   *
+   *  Despite of being highly esoteric, this function significantly simplifies signature analysis.
+   *  For example, it can be used to strip macroImpl.paramss from the evidences (necessary when checking def <-> impl correspondence)
+   *  or to streamline creation of the list of macro arguments.
+   */
+  def transformTypeTagEvidenceParams(macroImplRef: Tree, transform: (Symbol, Symbol) => Symbol): List[List[Symbol]] = {
+    val treeInfo.MacroImplReference(isBundle, owner, macroImpl, _) = macroImplRef
+    val paramss = macroImpl.paramss
+    if (paramss.isEmpty || paramss.last.isEmpty) return paramss // no implicit parameters in the signature => nothing to do
+    val rc =
+      if (isBundle) macroImpl.owner.tpe.member(nme.c)
+      else {
+        def cparam = paramss.head.head
+        if (paramss.head.isEmpty || !(cparam.tpe <:< MacroContextClass.tpe)) return paramss // no context parameter in the signature => nothing to do
+        cparam
+      }
+    def transformTag(param: Symbol): Symbol = param.tpe.dealias match {
+      case TypeRef(SingleType(SingleType(_, ac), universe), WeakTypeTagClass, targ :: Nil)
+      if ac == rc && universe == MacroContextUniverse =>
+        transform(param, targ.typeSymbol)
+      case _ =>
+        param
+    }
+    val transformed = paramss.last map transformTag filter (_ ne NoSymbol)
+    if (transformed.isEmpty) paramss.init else paramss.init :+ transformed
+  }
+
+  private def dealiasAndRewrap(tp: Type)(fn: Type => Type): Type = {
+    if (isRepeatedParamType(tp)) scalaRepeatedType(fn(tp.typeArgs.head.dealias))
+    else fn(tp.dealias)
+  }
+
+  /** Increases metalevel of the type, i.e. transforms:
+   *    * T to c.Expr[T]
+   *
+   *  @see Metalevels.scala for more information and examples about metalevels
+   */
+  def increaseMetalevel(pre: Type, tp: Type): Type = dealiasAndRewrap(tp) {
+    case tp => typeRef(pre, MacroContextExprClass, List(tp))
+  }
+
+  /** Decreases metalevel of the type, i.e. transforms:
+   *    * c.Expr[T] to T
+   *    * Anything else to Any
+   *
+   *  @see Metalevels.scala for more information and examples about metalevels
+   */
+  def decreaseMetalevel(tp: Type): Type = dealiasAndRewrap(tp) {
+    case ExprClassOf(runtimeType) => runtimeType
+    case _ => AnyClass.tpe // so that macro impls with rhs = ??? don't screw up our inference
+  }
+}
\ No newline at end of file
diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala
index f1fccd6069..a08633ffc8 100644
--- a/src/compiler/scala/tools/nsc/Global.scala
+++ b/src/compiler/scala/tools/nsc/Global.scala
@@ -9,6 +9,7 @@ package nsc
 
 import java.io.{ File, FileOutputStream, PrintWriter, IOException, FileNotFoundException }
 import java.nio.charset.{ Charset, CharsetDecoder, IllegalCharsetNameException, UnsupportedCharsetException }
+import java.util.UUID._
 import scala.compat.Platform.currentTime
 import scala.collection.{ mutable, immutable }
 import io.{ SourceReader, AbstractFile, Path }
@@ -16,6 +17,7 @@ import reporters.{ Reporter, ConsoleReporter }
 import util.{ ClassPath, MergedClassPath, StatisticsInfo, returning, stackTraceString, stackTraceHeadString }
 import scala.reflect.internal.util.{ OffsetPosition, SourceFile, NoSourceFile, BatchSourceFile, ScriptSourceFile }
 import scala.reflect.internal.pickling.{ PickleBuffer, PickleFormat }
+import scala.reflect.io.VirtualFile
 import symtab.{ Flags, SymbolTable, SymbolLoaders, SymbolTrackers }
 import symtab.classfile.Pickler
 import plugins.Plugins
@@ -1621,6 +1623,25 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
       }
     }
 
+    // TODO: provide a way to specify a pretty name for debugging purposes
+    private def randomFileName() = (
+      "compileLateSynthetic-" + randomUUID().toString.replace("-", "") + ".scala"
+    )
+
+    def compileLate(code: PackageDef) {
+      // compatibility with SBT
+      // on the one hand, we need to specify some jfile here, otherwise sbt crashes with an NPE (SI-6870)
+      // on the other hand, we can't specify the obvious enclosingUnit, because then sbt somehow fails to run tests using type macros
+      // okay, now let's specify a guaranteedly non-existent file in an existing directory (so that we don't run into permission problems)
+      val syntheticFileName = randomFileName()
+      val fakeJfile = new java.io.File(syntheticFileName)
+      val virtualFile = new VirtualFile(syntheticFileName) { override def file = fakeJfile }
+      val sourceFile = new BatchSourceFile(virtualFile, code.toString)
+      val unit = new CompilationUnit(sourceFile)
+      unit.body = code
+      compileLate(unit)
+    }
+
     /** Reset package class to state at typer (not sure what this
      *  is needed for?)
      */
diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
index 054f96c7b7..09ac13982d 100644
--- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
@@ -460,7 +460,7 @@ trait ContextErrors {
       def AbstractionFromVolatileTypeError(vd: ValDef) =
         issueNormalTypeError(vd, "illegal abstraction from value with volatile type "+vd.symbol.tpe)
 
-      private[ContextErrors] def TypedApplyWrongNumberOfTpeParametersErrorMessage(fun: Tree) =
+      private[scala] def TypedApplyWrongNumberOfTpeParametersErrorMessage(fun: Tree) =
         "wrong number of type parameters for "+treeSymTypeMsg(fun)
 
       def TypedApplyWrongNumberOfTpeParametersError(tree: Tree, fun: Tree) = {
@@ -692,7 +692,6 @@ trait ContextErrors {
         issueNormalTypeError(expandee, s"macro in $role role can only expand into $allowedExpansions")
       }
 
-      // same reason as for MacroBodyTypecheckException
       case object MacroExpansionException extends Exception with scala.util.control.ControlThrowable
 
       protected def macroExpansionError(expandee: Tree, msg: String, pos: Position = NoPosition) = {
@@ -712,14 +711,14 @@ trait ContextErrors {
       }
 
       private def MacroTooFewArgumentListsMessage = "too few argument lists for macro invocation"
-      def MacroTooFewArgumentLists(expandee: Tree) = macroExpansionError2(expandee, MacroTooFewArgumentListsMessage)
+      def MacroTooFewArgumentListsError(expandee: Tree) = macroExpansionError2(expandee, MacroTooFewArgumentListsMessage)
 
       private def MacroTooManyArgumentListsMessage = "too many argument lists for macro invocation"
-      def MacroTooManyArgumentLists(expandee: Tree) = macroExpansionError2(expandee, MacroTooManyArgumentListsMessage)
+      def MacroTooManyArgumentListsError(expandee: Tree) = macroExpansionError2(expandee, MacroTooManyArgumentListsMessage)
 
-      def MacroTooFewArguments(expandee: Tree) = macroExpansionError2(expandee, "too few arguments for macro invocation")
+      def MacroTooFewArgumentsError(expandee: Tree) = macroExpansionError2(expandee, "too few arguments for macro invocation")
 
-      def MacroTooManyArguments(expandee: Tree) = macroExpansionError2(expandee, "too many arguments for macro invocation")
+      def MacroTooManyArgumentsError(expandee: Tree) = macroExpansionError2(expandee, "too many arguments for macro invocation")
 
       def MacroGeneratedAbort(expandee: Tree, ex: AbortMacroException) = {
         // errors have been reported by the macro itself, so we do nothing here
@@ -926,7 +925,7 @@ trait ContextErrors {
           kindErrors.toList.mkString("\n", ", ", ""))
       }
 
-      private[ContextErrors] def NotWithinBoundsErrorMessage(prefix: String, targs: List[Type], tparams: List[Symbol], explaintypes: Boolean) = {
+      private[scala] def NotWithinBoundsErrorMessage(prefix: String, targs: List[Type], tparams: List[Symbol], explaintypes: Boolean) = {
         if (explaintypes) {
           val bounds = tparams map (tp => tp.info.instantiateTypeParams(tparams, targs).bounds)
           (targs, bounds).zipped foreach ((targ, bound) => explainTypes(bound.lo, targ))
@@ -1233,149 +1232,4 @@ trait ContextErrors {
       setError(arg)
     }
   }
-
-  // using an exception here is actually a good idea
-  // because the lifespan of this exception is extremely small and controlled
-  // moreover exceptions let us avoid an avalanche of "if (!hasError) do stuff" checks
-  case object MacroBodyTypecheckException extends Exception with scala.util.control.ControlThrowable
-
-  trait MacroErrors {
-    self: MacroTyper =>
-
-    private implicit val context0 = typer.context
-    val context = typer.context
-
-    // helpers
-
-    private def lengthMsg(flavor: String, violation: String, extra: Symbol) = {
-      val noun = if (flavor == "value") "parameter" else "type parameter"
-      val message = noun + " lists have different length, " + violation + " extra " + noun
-      val suffix = if (extra ne NoSymbol) " " + extra.defString else ""
-      message + suffix
-    }
-
-    private def abbreviateCoreAliases(s: String): String = List("WeakTypeTag", "Expr").foldLeft(s)((res, x) => res.replace("c.universe." + x, "c." + x))
-
-    private def showMeth(pss: List[List[Symbol]], restpe: Type, abbreviate: Boolean) = {
-      var argsPart = (pss map (ps => ps map (_.defString) mkString ("(", ", ", ")"))).mkString
-      if (abbreviate) argsPart = abbreviateCoreAliases(argsPart)
-      var retPart = restpe.toString
-      if (abbreviate || macroDdef.tpt.tpe == null) retPart = abbreviateCoreAliases(retPart)
-      argsPart + ": " + retPart
-    }
-
-    // not exactly an error generator, but very related
-    // and I dearly wanted to push it away from Macros.scala
-    private def checkConforms(slot: String, rtpe: Type, atpe: Type) = {
-      val verbose = macroDebugVerbose || settings.explaintypes.value
-
-      def check(rtpe: Type, atpe: Type): Boolean = {
-        if (rtpe eq atpe) { if (verbose) println(rtpe + " <: " + atpe + "?" + EOL + "true"); true }
-        else rtpe <:< atpe
-      }
-
-      val ok =
-        if (verbose) withTypesExplained(check(rtpe, atpe))
-        else check(rtpe, atpe)
-      if (!ok) {
-        if (!macroDebugVerbose)
-          explainTypes(rtpe, atpe)
-        compatibilityError("type mismatch for %s: %s does not conform to %s".format(slot, abbreviateCoreAliases(rtpe.toString), abbreviateCoreAliases(atpe.toString)))
-      }
-    }
-
-    // errors
-
-    private def fail() = {
-      // need to set the IS_ERROR flag to prohibit spurious expansions
-      if (macroDef != null) macroDef setFlag IS_ERROR
-      // not setting ErrorSymbol as in `infer.setError`, because we still need to know that it's a macro
-      // otherwise assignTypeToTree in Namers might fail if macroDdef.tpt == EmptyTree
-      macroDdef setType ErrorType
-      throw MacroBodyTypecheckException
-    }
-
-    private def genericError(tree: Tree, message: String) = {
-      issueNormalTypeError(tree, message)
-      fail()
-    }
-
-    private def implRefError(message: String) = {
-      val treeInfo.Applied(implRef, _, _) = macroDdef.rhs
-      genericError(implRef, message)
-    }
-
-    private def compatibilityError(message: String) =
-      implRefError(
-        "macro implementation has wrong shape:"+
-        "\n required: " + showMeth(rparamss, rret, abbreviate = true) +
-        "\n found   : " + showMeth(aparamss, aret, abbreviate = false) +
-        "\n" + message)
-
-    // Phase I: sanity checks
-
-    def MacroDefIsFastTrack() = {
-      macroLogVerbose("typecheck terminated unexpectedly: macro is fast track")
-      assert(!macroDdef.tpt.isEmpty, "fast track macros must provide result type")
-      throw MacroBodyTypecheckException // don't call fail, because we don't need IS_ERROR
-    }
-
-    def MacroDefIsQmarkQmarkQmark() = {
-      macroLogVerbose("typecheck terminated unexpectedly: macro is ???")
-      throw MacroBodyTypecheckException
-    }
-
-    def MacroFeatureNotEnabled() = {
-      macroLogVerbose("typecheck terminated unexpectedly: language.experimental.macros feature is not enabled")
-      fail()
-    }
-
-    // Phase II: typecheck the right-hand side of the macro def
-
-    // do nothing, just fail. relevant typecheck errors have already been reported
-    def MacroDefUntypeableBodyError() = fail()
-
-    def MacroDefInvalidBodyError() = genericError(macroDdef, "macro body has wrong shape:\n required: macro [<implementation object>].<method name>[[<type args>]]")
-
-    def MacroImplNotPublicError() = implRefError("macro implementation must be public")
-
-    def MacroImplOverloadedError() = implRefError("macro implementation cannot be overloaded")
-
-    def MacroImplWrongNumberOfTypeArgumentsError(macroImplRef: Tree) = implRefError(typer.TyperErrorGen.TypedApplyWrongNumberOfTpeParametersErrorMessage(macroImplRef))
-
-    def MacroImplNotStaticError() = implRefError("macro implementation must be in statically accessible object")
-
-    // Phase III: check compatibility between the macro def and its macro impl
-    // aXXX (e.g. aparams) => characteristics of the macro impl ("a" stands for "actual")
-    // rXXX (e.g. rparams) => characteristics of a reference macro impl signature synthesized from the macro def ("r" stands for "reference")
-
-    def MacroImplNonTagImplicitParameters(params: List[Symbol]) = compatibilityError("macro implementations cannot have implicit parameters other than WeakTypeTag evidences")
-
-    def MacroImplParamssMismatchError() = compatibilityError("number of parameter sections differ")
-
-    def MacroImplExtraParamsError(aparams: List[Symbol], rparams: List[Symbol]) = compatibilityError(lengthMsg("value", "found", aparams(rparams.length)))
-
-    def MacroImplMissingParamsError(aparams: List[Symbol], rparams: List[Symbol]) = compatibilityError(abbreviateCoreAliases(lengthMsg("value", "required", rparams(aparams.length))))
-
-    def checkMacroImplParamTypeMismatch(atpe: Type, rparam: Symbol) = checkConforms("parameter " + rparam.name, rparam.tpe, atpe)
-
-    def checkMacroImplResultTypeMismatch(atpe: Type, rret: Type) = checkConforms("return type", atpe, rret)
-
-    def MacroImplParamNameMismatchError(aparam: Symbol, rparam: Symbol) = compatibilityError("parameter names differ: " + rparam.name + " != " + aparam.name)
-
-    def MacroImplVarargMismatchError(aparam: Symbol, rparam: Symbol) = {
-      if (isRepeated(rparam) && !isRepeated(aparam))
-        compatibilityError("types incompatible for parameter " + rparam.name + ": corresponding is not a vararg parameter")
-      if (!isRepeated(rparam) && isRepeated(aparam))
-        compatibilityError("types incompatible for parameter " + aparam.name + ": corresponding is not a vararg parameter")
-    }
-
-    def MacroImplTargMismatchError(atargs: List[Type], atparams: List[Symbol]) =
-      compatibilityError(typer.infer.InferErrorGen.NotWithinBoundsErrorMessage("", atargs, atparams, macroDebugVerbose || settings.explaintypes))
-
-    def MacroImplTparamInstantiationError(atparams: List[Symbol], ex: NoInstance) =
-      compatibilityError(
-        "type parameters "+(atparams map (_.defString) mkString ", ")+" cannot be instantiated\n"+
-        ex.getMessage)
-  }
 }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
index 93f73f1bbe..40f284c94c 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
@@ -11,6 +11,8 @@ import scala.reflect.internal.util.Statistics
 import scala.reflect.macros.util._
 import scala.util.control.ControlThrowable
 import scala.reflect.macros.runtime.AbortMacroException
+import scala.reflect.runtime.{universe => ru}
+import scala.reflect.macros.compiler.DefaultMacroCompiler
 
 /**
  *  Code to deal with macros, namely with:
@@ -37,7 +39,7 @@ import scala.reflect.macros.runtime.AbortMacroException
  *    (Expr(elems))
  *    (TypeTag(Int))
  */
-trait Macros extends scala.tools.reflect.FastTrack with Traces {
+trait Macros extends scala.tools.reflect.FastTrack with Traces with Helpers {
   self: Analyzer =>
 
   import global._
@@ -76,6 +78,8 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
    *  and various accounting information necessary when composing an argument list for the reflective invocation.
    */
   private case class MacroImplBinding(
+    // Is this macro impl a bundle (a trait extending Macro) or a vanilla def?
+    val isBundle: Boolean,
     // Java class name of the class that contains the macro implementation
     // is used to load the corresponding object with Java reflection
     className: String,
@@ -110,19 +114,21 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
    *
    *    @scala.reflect.macros.internal.macroImpl(
    *      `macro`(
+   *        "isBundle" = false,
    *        "signature" = List(-1),
    *        "methodName" = "impl",
    *        "versionFormat" = <current version format>,
    *        "className" = "Macros$"))
    */
   private object MacroImplBinding {
-    val versionFormat = 2
+    val versionFormat = 3
 
     def pickleAtom(obj: Any): Tree =
       obj match {
         case list: List[_] => Apply(Ident(ListModule), list map pickleAtom)
         case s: String => Literal(Constant(s))
         case i: Int => Literal(Constant(i))
+        case b: Boolean => Literal(Constant(b))
       }
 
     def unpickleAtom(tree: Tree): Any =
@@ -130,11 +136,11 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
         case Apply(list @ Ident(_), args) if list.symbol == ListModule => args map unpickleAtom
         case Literal(Constant(s: String)) => s
         case Literal(Constant(i: Int)) => i
+        case Literal(Constant(b: Boolean)) => b
       }
 
     def pickle(macroImplRef: Tree): Tree = {
-      val MacroImplReference(owner, macroImpl, targs) = macroImplRef
-      val paramss = macroImpl.paramss
+      val MacroImplReference(isBundle, owner, macroImpl, targs) = macroImplRef
 
       // todo. refactor when fixing SI-5498
       def className: String = {
@@ -157,12 +163,13 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
           case _ => IMPLPARAM_OTHER
         }
 
-        val transformed = transformTypeTagEvidenceParams(paramss, (param, tparam) => tparam)
+        val transformed = transformTypeTagEvidenceParams(macroImplRef, (param, tparam) => tparam)
         mmap(transformed)(p => if (p.isTerm) fingerprint(p.info) else p.paramPos)
       }
 
       val payload = List[(String, Any)](
         "versionFormat" -> versionFormat,
+        "isBundle"      -> isBundle,
         "className"     -> className,
         "methodName"    -> macroImpl.name.toString,
         "signature"     -> signature
@@ -205,10 +212,11 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
       val pickleVersionFormat = payload("versionFormat").asInstanceOf[Int]
       if (versionFormat != pickleVersionFormat) throw new Error(s"macro impl binding format mismatch: expected $versionFormat, actual $pickleVersionFormat")
 
+      val isBundle = payload("isBundle").asInstanceOf[Boolean]
       val className = payload("className").asInstanceOf[String]
       val methodName = payload("methodName").asInstanceOf[String]
       val signature = payload("signature").asInstanceOf[List[List[Int]]]
-      MacroImplBinding(className, methodName, signature, targs)
+      MacroImplBinding(isBundle, className, methodName, signature, targs)
     }
   }
 
@@ -222,330 +230,82 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
     MacroImplBinding.unpickle(pickle)
   }
 
-  /** Transforms parameters lists of a macro impl.
-   *  The `transform` function is invoked only for WeakTypeTag evidence parameters.
-   *
-   *  The transformer takes two arguments: a value parameter from the parameter list
-   *  and a type parameter that is witnesses by the value parameter.
-   *
-   *  If the transformer returns a NoSymbol, the value parameter is not included from the result.
-   *  If the transformer returns something else, this something else is included in the result instead of the value parameter.
-   *
-   *  Despite of being highly esoteric, this function significantly simplifies signature analysis.
-   *  For example, it can be used to strip macroImpl.paramss from the evidences (necessary when checking def <-> impl correspondence)
-   *  or to streamline creation of the list of macro arguments.
-   */
-  private def transformTypeTagEvidenceParams(paramss: List[List[Symbol]], transform: (Symbol, Symbol) => Symbol): List[List[Symbol]] = {
-    if (paramss.isEmpty || paramss.last.isEmpty) return paramss // no implicit parameters in the signature => nothing to do
-    if (paramss.head.isEmpty || !(paramss.head.head.tpe <:< MacroContextClass.tpe)) return paramss // no context parameter in the signature => nothing to do
-    def transformTag(param: Symbol): Symbol = param.tpe.dealias match {
-      case TypeRef(SingleType(SingleType(NoPrefix, c), universe), WeakTypeTagClass, targ :: Nil)
-      if c == paramss.head.head && universe == MacroContextUniverse =>
-        transform(param, targ.typeSymbol)
-      case _ =>
-        param
-    }
-    val transformed = paramss.last map transformTag filter (_ ne NoSymbol)
-    if (transformed.isEmpty) paramss.init else paramss.init :+ transformed
-  }
-
-  private def dealiasAndRewrap(tp: Type)(fn: Type => Type): Type = {
-    if (isRepeatedParamType(tp)) scalaRepeatedType(fn(tp.typeArgs.head.dealias))
-    else fn(tp.dealias)
-  }
-
-  /** Increases metalevel of the type, i.e. transforms:
-   *    * T to c.Expr[T]
-   *
-   *  @see Metalevels.scala for more information and examples about metalevels
-   */
-  private def increaseMetalevel(c: Symbol, tp: Type): Type = dealiasAndRewrap(tp) {
-    case tp => typeRef(SingleType(NoPrefix, c), MacroContextExprClass, List(tp))
-  }
-
-  /** Decreases metalevel of the type, i.e. transforms:
-   *    * c.Expr[T] to T
-   *
-   *  @see Metalevels.scala for more information and examples about metalevels
-   */
-  private def decreaseMetalevel(tp: Type): Type = dealiasAndRewrap(tp) {
-    case ExprClassOf(runtimeType) => runtimeType
-    case _ => AnyClass.tpe // so that macro impls with rhs = ??? don't screw up our inference
-  }
-
-  def computeMacroDefTypeFromMacroImpl(macroDdef: DefDef, macroImplSig: MacroImplSig): Type = {
-    // Step I. Transform c.Expr[T] to T and c.Tree to <untyped>
-    var runtimeType = decreaseMetalevel(macroImplSig.ret)
-
-    // Step II. Transform type parameters of a macro implementation into type arguments in a macro definition's body
-    runtimeType = runtimeType.substituteTypes(macroImplSig.tparams, loadMacroImplBinding(macroDdef.symbol).targs.map(_.tpe))
-
-    // Step III. Transform c.prefix.value.XXX to this.XXX and implParam.value.YYY to defParam.YYY
-    def unsigma(tpe: Type): Type =
-      transformTypeTagEvidenceParams(macroImplSig.paramss, (param, tparam) => NoSymbol) match {
-        case (implCtxParam :: Nil) :: implParamss =>
-          val implToDef = flatMap2(implParamss, macroDdef.vparamss)(map2(_, _)((_, _))).toMap
-          object UnsigmaTypeMap extends TypeMap {
-            def apply(tp: Type): Type = tp match {
-              case TypeRef(pre, sym, args) =>
-                val pre1 = pre match {
-                  case SingleType(SingleType(SingleType(NoPrefix, c), prefix), value) if c == implCtxParam && prefix == MacroContextPrefix && value == ExprValue =>
-                    ThisType(macroDdef.symbol.owner)
-                  case SingleType(SingleType(NoPrefix, implParam), value) if value == ExprValue =>
-                    implToDef get implParam map (defParam => SingleType(NoPrefix, defParam.symbol)) getOrElse pre
+  def computeMacroDefTypeFromMacroImplRef(macroDdef: DefDef, macroImplRef: Tree): Type = {
+    macroImplRef match {
+      case MacroImplReference(_, _, macroImpl, targs) =>
+        // Step I. Transform c.Expr[T] to T and everything else to Any
+        var runtimeType = decreaseMetalevel(macroImpl.info.finalResultType)
+
+        // Step II. Transform type parameters of a macro implementation into type arguments in a macro definition's body
+        runtimeType = runtimeType.substituteTypes(macroImpl.typeParams, targs map (_.tpe))
+
+        // Step III. Transform c.prefix.value.XXX to this.XXX and implParam.value.YYY to defParam.YYY
+        def unsigma(tpe: Type): Type =
+          transformTypeTagEvidenceParams(macroImplRef, (param, tparam) => NoSymbol) match {
+            case (implCtxParam :: Nil) :: implParamss =>
+              val implToDef = flatMap2(implParamss, macroDdef.vparamss)(map2(_, _)((_, _))).toMap
+              object UnsigmaTypeMap extends TypeMap {
+                def apply(tp: Type): Type = tp match {
+                  case TypeRef(pre, sym, args) =>
+                    val pre1 = pre match {
+                      case SingleType(SingleType(SingleType(NoPrefix, c), prefix), value) if c == implCtxParam && prefix == MacroContextPrefix && value == ExprValue =>
+                        ThisType(macroDdef.symbol.owner)
+                      case SingleType(SingleType(NoPrefix, implParam), value) if value == ExprValue =>
+                        implToDef get implParam map (defParam => SingleType(NoPrefix, defParam.symbol)) getOrElse pre
+                      case _ =>
+                        pre
+                    }
+                    val args1 = args map mapOver
+                    TypeRef(pre1, sym, args1)
                   case _ =>
-                    pre
+                    mapOver(tp)
                 }
-                val args1 = args map mapOver
-                TypeRef(pre1, sym, args1)
-              case _ =>
-                mapOver(tp)
-            }
-          }
-
-          UnsigmaTypeMap(tpe)
-        case _ =>
-          tpe
-      }
-
-    unsigma(runtimeType)
-  }
-
-  /** Signature of a macro implementation, used to check def <-> impl correspondence.
-   *
-   *  Technically it can be just an alias to MethodType, but promoting it to a first-class entity
-   *  provides better encapsulation and convenient syntax for pattern matching.
-   */
-  case class MacroImplSig(tparams: List[Symbol], paramss: List[List[Symbol]], ret: Type)
+              }
 
-  /** An actual macro implementation signature extracted from a macro implementation method.
-   *
-   *  In the example above for the following macro impl:
-   *    def fooBar[T: c.WeakTypeTag]
-   *           (c: scala.reflect.macros.Context)
-   *           (xs: c.Expr[List[T]])
-   *           : c.Expr[T] = ...
-   *
-   *  This function will return:
-   *    (c: scala.reflect.macros.Context)(xs: c.Expr[List[T]])c.Expr[T]
-   *
-   *  Note that type tag evidence parameters are not included into the result.
-   *  Type tag context bounds for macro impl tparams are optional.
-   *  Therefore compatibility checks ignore such parameters, and we don't need to bother about them here.
-   *
-   *  This method cannot be reduced to just macroImpl.info, because macro implementations might
-   *  come in different shapes. If the implementation is an apply method of a Macro-compatible object,
-   *  then it won't have (c: Context) in its parameters, but will rather refer to Macro.c.
-   *
-   *  @param macroImpl The macro implementation symbol
-   */
-  def macroImplSig(macroImpl: Symbol): MacroImplSig = {
-    val tparams = macroImpl.typeParams
-    val paramss = transformTypeTagEvidenceParams(macroImpl.paramss, (param, tparam) => NoSymbol)
-    val ret = macroImpl.info.finalResultType
-    MacroImplSig(tparams, paramss, ret)
-  }
+              UnsigmaTypeMap(tpe)
+            case _ =>
+              tpe
+          }
 
-  /** A reference macro implementation signature extracted from a given macro definition.
-   *
-   *  In the example above for the following macro def:
-   *    def foo[T](xs: List[T]): T = macro fooBar
-   *
-   *  This function will return:
-   *    (c: scala.reflect.macros.Context)(xs: c.Expr[List[T]])c.Expr[T]
-   *
-   *  Note that type tag evidence parameters are not included into the result.
-   *  Type tag context bounds for macro impl tparams are optional.
-   *  Therefore compatibility checks ignore such parameters, and we don't need to bother about them here.
-   *
-   *  Also note that we need a DefDef, not the corresponding MethodSymbol, because that symbol would be of no use for us.
-   *  Macro signatures are verified when typechecking macro defs, which means that at that moment inspecting macroDef.info
-   *  means asking for cyclic reference errors.
-   *
-   *  We need macro implementation symbol as well, because the return type of the macro definition might be omitted,
-   *  and in that case we'd need to infer it from the return type of the macro implementation. Luckily for us, we can
-   *  use that symbol without a risk of running into cycles.
-   *
-   *  @param typer     Typechecker of `macroDdef`
-   *  @param macroDdef The macro definition tree
-   *  @param macroImpl The macro implementation symbol
-   */
-  def referenceMacroImplSig(typer: Typer, macroDdef: DefDef, macroImpl: Symbol): MacroImplSig = {
-    // had to move method's body to an object because of the recursive dependencies between sigma and param
-    object SigGenerator {
-      val cache    = scala.collection.mutable.Map[Symbol, Symbol]()
-      val macroDef = macroDdef.symbol
-      val ctxParam = makeParam(nme.macroContext, macroDdef.pos, MacroContextClass.tpe, SYNTHETIC)
-      val paramss  = List(ctxParam) :: mmap(macroDdef.vparamss)(param)
-      val macroDefRet =
-        if (!macroDdef.tpt.isEmpty) typer.typedType(macroDdef.tpt).tpe
-        else computeMacroDefTypeFromMacroImpl(macroDdef, macroImplSig(macroImpl))
-      val implReturnType = sigma(increaseMetalevel(ctxParam, macroDefRet))
-
-      object SigmaTypeMap extends TypeMap {
-        def mapPrefix(pre: Type) = pre match {
-          case ThisType(sym) if sym == macroDef.owner =>
-            singleType(singleType(singleType(NoPrefix, ctxParam), MacroContextPrefix), ExprValue)
-          case SingleType(NoPrefix, sym) =>
-            mfind(macroDdef.vparamss)(_.symbol == sym).fold(pre)(p => singleType(singleType(NoPrefix, param(p)), ExprValue))
-          case _ =>
-            mapOver(pre)
-        }
-        def apply(tp: Type): Type = tp match {
-          case TypeRef(pre, sym, args) =>
-            val pre1  = mapPrefix(pre)
-            val args1 = mapOverArgs(args, sym.typeParams)
-            if ((pre eq pre1) && (args eq args1)) tp
-            else typeRef(pre1, sym, args1)
-          case _ =>
-            mapOver(tp)
-        }
-      }
-      def sigma(tpe: Type): Type = SigmaTypeMap(tpe)
-
-      def makeParam(name: Name, pos: Position, tpe: Type, flags: Long) =
-        macroDef.newValueParameter(name.toTermName, pos, flags) setInfo tpe
-      def param(tree: Tree): Symbol = (
-        cache.getOrElseUpdate(tree.symbol, {
-          val sym = tree.symbol
-          assert(sym.isTerm, s"sym = $sym, tree = $tree")
-          makeParam(sym.name, sym.pos, sigma(increaseMetalevel(ctxParam, sym.tpe)), sym.flags)
-        })
-      )
+        unsigma(runtimeType)
+      case _ =>
+        ErrorType
     }
-
-    import SigGenerator._
-    val result = MacroImplSig(macroDdef.tparams map (_.symbol), paramss, implReturnType)
-    macroLogVerbose(sm"""
-      |generating macroImplSig for: $macroDdef
-      |result is: $result
-    """.trim)
-    result
   }
 
-  /** Verifies that the body of a macro def typechecks to a reference to a static public non-overloaded method,
+  /** Verifies that the body of a macro def typechecks to a reference to a static public non-overloaded method or a top-level macro bundle,
    *  and that that method is signature-wise compatible with the given macro definition.
    *
-   *  @return Typechecked rhs of the given macro definition if everything is okay.
+   *  @return Macro impl reference for the given macro definition if everything is okay.
    *          EmptyTree if an error occurs.
    */
-  def typedMacroBody(typer: Typer, macroDdef: DefDef): Tree =
-    try new MacroTyper(typer, macroDdef).typed
-    catch { case MacroBodyTypecheckException => EmptyTree }
-
-  class MacroTyper(val typer: Typer, val macroDdef: DefDef) extends MacroErrors {
-    private def typed1Expr(tree: Tree) = typer.typed1(tree, EXPRmode, WildcardType)
-
-    // Phase I: sanity checks
+  def typedMacroBody(typer: Typer, macroDdef: DefDef): Tree = {
     val macroDef = macroDdef.symbol
-    macroLogVerbose("typechecking macro def %s at %s".format(macroDef, macroDdef.pos))
     assert(macroDef.isMacro, macroDdef)
-    if (fastTrack contains macroDef) MacroDefIsFastTrack()
-    if (!typer.checkFeature(macroDdef.pos, MacrosFeature, immediate = true)) MacroFeatureNotEnabled()
-
-    // we use typed1 instead of typed, because otherwise adapt is going to mess us up
-    // if adapt sees <qualifier>.<method>, it will want to perform eta-expansion and will fail
-    // unfortunately, this means that we have to manually trigger macro expansion
-    // because it's adapt which is responsible for automatic expansion during typechecking
-    def typecheckRhs(rhs: Tree): Tree = {
-      try {
-        // interestingly enough, just checking isErroneous doesn't cut it
-        // e.g. a "type arguments [U] do not conform to method foo's type parameter bounds" error
-        // doesn't manifest itself as an error in the resulting tree
-        val prevNumErrors = reporter.ERROR.count
-        var rhs1 = typed1Expr(rhs)
-        def rhsNeedsMacroExpansion = rhs1.symbol != null && rhs1.symbol.isTermMacro && !rhs1.symbol.isErroneous
-        while (rhsNeedsMacroExpansion) {
-          rhs1 = macroExpand1(typer, rhs1) match {
-            case Success(expanded) =>
-              try {
-                val typechecked = typed1Expr(expanded)
-                macroLogVerbose("typechecked1:%n%s%n%s".format(typechecked, showRaw(typechecked)))
-                typechecked
-              } finally {
-                popMacroContext()
-              }
-            case Fallback(fallback) =>
-              typed1Expr(fallback)
-            case Delayed(delayed) =>
-              typer.instantiate(delayed, EXPRmode, WildcardType)
-            case Skipped(skipped) =>
-              skipped
-            case Failure(failure) =>
-              failure
-          }
-        }
-        val typecheckedWithErrors = (rhs1 exists (_.isErroneous)) || reporter.ERROR.count != prevNumErrors
-        if (typecheckedWithErrors) MacroDefUntypeableBodyError()
-        rhs1
-      } catch {
-        case ex: TypeError =>
-          typer.reportTypeError(context, rhs.pos, ex)
-          MacroDefUntypeableBodyError()
-      }
-    }
 
-    // Phase II: typecheck the right-hand side of the macro def
-    val typed = typecheckRhs(macroDdef.rhs)
-    typed match {
-      case MacroImplReference(_, meth, _) if meth == Predef_??? =>
-        bindMacroImpl(macroDef, typed)
-        MacroDefIsQmarkQmarkQmark()
-      case MacroImplReference(owner, meth, targs) =>
-        if (!meth.isMethod) MacroDefInvalidBodyError()
-        if (!meth.isPublic) MacroImplNotPublicError()
-        if (meth.isOverloaded) MacroImplOverloadedError()
-        if (!owner.isStaticOwner && !owner.moduleClass.isStaticOwner) MacroImplNotStaticError()
-        if (meth.typeParams.length != targs.length) MacroImplWrongNumberOfTypeArgumentsError(typed)
-        bindMacroImpl(macroDef, typed)
-      case _ =>
-        MacroDefInvalidBodyError()
-    }
-
-    // Phase III: check compatibility between the macro def and its macro impl
-    // this check ignores type tag evidence parameters, because type tag context bounds are optional
-    // aXXX (e.g. aparamss) => characteristics of the actual macro impl signature extracted from the macro impl ("a" stands for "actual")
-    // rXXX (e.g. rparamss) => characteristics of the reference macro impl signature synthesized from the macro def ("r" stands for "reference")
-    val macroImpl = typed.symbol
-    val MacroImplSig(atparams, aparamss, aret) = macroImplSig(macroImpl)
-    val MacroImplSig(_, rparamss, rret) = referenceMacroImplSig(typer, macroDdef, macroImpl)
-    val atvars = atparams map freshVar
-    def atpeToRtpe(atpe: Type) = atpe.substSym(aparamss.flatten, rparamss.flatten).instantiateTypeParams(atparams, atvars)
-
-    // we only check correspondence between value parameterss
-    // type parameters of macro defs and macro impls don't have to coincide with each other
-    val implicitParams = aparamss.flatten filter (_.isImplicit)
-    if (implicitParams.nonEmpty) MacroImplNonTagImplicitParameters(implicitParams)
-    if (aparamss.length != rparamss.length) MacroImplParamssMismatchError()
-    map2(aparamss, rparamss)((aparams, rparams) => {
-      if (aparams.length < rparams.length) MacroImplMissingParamsError(aparams, rparams)
-      if (rparams.length < aparams.length) MacroImplExtraParamsError(aparams, rparams)
-    })
-
-    try {
-      // cannot fuse this map2 and the map2 above because if aparamss.flatten != rparamss.flatten
-      // then `atpeToRtpe` is going to fail with an unsound substitution
-      map2(aparamss.flatten, rparamss.flatten)((aparam, rparam) => {
-        if (aparam.name != rparam.name && !rparam.isSynthetic) MacroImplParamNameMismatchError(aparam, rparam)
-        if (isRepeated(aparam) ^ isRepeated(rparam)) MacroImplVarargMismatchError(aparam, rparam)
-        val aparamtpe = aparam.tpe.dealias match {
-          case RefinedType(List(tpe), Scope(sym)) if tpe =:= MacroContextClass.tpe && sym.allOverriddenSymbols.contains(MacroContextPrefixType) => tpe
-          case tpe => tpe
-        }
-        checkMacroImplParamTypeMismatch(atpeToRtpe(aparamtpe), rparam)
-      })
-
-      checkMacroImplResultTypeMismatch(atpeToRtpe(aret), rret)
-
-      val maxLubDepth = lubDepth(aparamss.flatten map (_.tpe)) max lubDepth(rparamss.flatten map (_.tpe))
-      val atargs = solvedTypes(atvars, atparams, atparams map varianceInType(aret), upper = false, depth = maxLubDepth)
-      val boundsOk = typer.silent(_.infer.checkBounds(macroDdef, NoPrefix, NoSymbol, atparams, atargs, ""))
-      boundsOk match {
-        case SilentResultValue(true) => // do nothing, success
-        case SilentResultValue(false) | SilentTypeError(_) => MacroImplTargMismatchError(atargs, atparams)
+    macroLogVerbose("typechecking macro def %s at %s".format(macroDef, macroDdef.pos))
+    if (fastTrack contains macroDef) {
+      macroLogVerbose("typecheck terminated unexpectedly: macro is fast track")
+      assert(!macroDdef.tpt.isEmpty, "fast track macros must provide result type")
+      EmptyTree
+    } else {
+      def fail() = { if (macroDef != null) macroDef setFlag IS_ERROR; macroDdef setType ErrorType; EmptyTree }
+      def success(macroImplRef: Tree) = { bindMacroImpl(macroDef, macroImplRef); macroImplRef }
+
+      if (!typer.checkFeature(macroDdef.pos, MacrosFeature, immediate = true)) {
+        macroLogVerbose("typecheck terminated unexpectedly: language.experimental.macros feature is not enabled")
+        fail()
+      } else {
+        val macroDdef1: macroDdef.type = macroDdef
+        val typer1: typer.type = typer
+        val macroCompiler = new {
+          val global: self.global.type = self.global
+          val typer: self.global.analyzer.Typer = typer1.asInstanceOf[self.global.analyzer.Typer]
+          val macroDdef: self.global.DefDef = macroDdef1
+        } with DefaultMacroCompiler
+        val macroImplRef = macroCompiler.resolveMacroImpl
+        if (macroImplRef.isEmpty) fail() else success(macroImplRef)
       }
-    } catch {
-      case ex: NoInstance => MacroImplTparamInstantiationError(atparams, ex)
     }
   }
 
@@ -555,6 +315,10 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
    */
   lazy val macroClassloader: ClassLoader = findMacroClassLoader()
 
+  /** Reflective mirror built from `macroClassloader`.
+   */
+  private lazy val macroMirror: ru.JavaMirror = ru.runtimeMirror(macroClassloader)
+
   /** Produces a function that can be used to invoke macro implementation for a given macro definition:
    *    1) Looks up macro implementation symbol in this universe.
    *    2) Loads its enclosing class from the macro classloader.
@@ -574,28 +338,32 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
     } else {
       macroRuntimesCache.getOrElseUpdate(macroDef, {
         val binding = loadMacroImplBinding(macroDef)
+        val isBundle = binding.isBundle
         val className = binding.className
         val methName = binding.methName
         macroLogVerbose(s"resolved implementation as $className.$methName")
 
-        if (binding.className == Predef_???.owner.fullName.toString && binding.methName == Predef_???.name.encoded) {
+        if (binding.className == Predef_???.owner.javaClassName && binding.methName == Predef_???.name.encoded) {
           args => throw new AbortMacroException(args.c.enclosingPosition, "macro implementation is missing")
         } else {
-          // I don't use Scala reflection here, because it seems to interfere with JIT magic
-          // whenever you instantiate a mirror (and not do anything with in, just instantiate), performance drops by 15-20%
-          // I'm not sure what's the reason - for me it's pure voodoo
-          // upd. my latest experiments show that everything's okay
-          // it seems that in 2.10.1 we can easily switch to Scala reflection
           try {
             macroLogVerbose(s"loading implementation class: $className")
             macroLogVerbose(s"classloader is: ${ReflectionUtils.show(macroClassloader)}")
-            val implObj = ReflectionUtils.staticSingletonInstance(macroClassloader, className)
-            // relies on the fact that macro impls cannot be overloaded
-            // so every methName can resolve to at maximum one method
-            val implMeths = implObj.getClass.getDeclaredMethods.find(_.getName == methName)
-            val implMeth = implMeths getOrElse { throw new NoSuchMethodException(s"$className.$methName") }
-            macroLogVerbose(s"successfully loaded macro impl as ($implObj, $implMeth)")
-            args => implMeth.invoke(implObj, ((args.c +: args.others) map (_.asInstanceOf[AnyRef])): _*)
+            val implContainerSym = macroMirror.classSymbol(Class.forName(className, true, macroClassloader))
+            val implMethSym = implContainerSym.typeSignature.member(ru.TermName(methName)).asMethod
+            macroLogVerbose(s"successfully loaded macro impl as ($implContainerSym, $implMethSym)")
+            args => {
+              val implContainer =
+                if (isBundle) {
+                  val implCtorSym = implContainerSym.typeSignature.member(ru.nme.CONSTRUCTOR).asMethod
+                  macroMirror.reflectClass(implContainerSym).reflectConstructor(implCtorSym)(args.c)
+                } else {
+                  macroMirror.reflectModule(implContainerSym.module.asModule).instance
+                }
+              val implMeth = macroMirror.reflect(implContainer).reflectMethod(implMethSym)
+              val implArgs = if (isBundle) args.others else args.c +: args.others
+              implMeth(implArgs: _*)
+            }
           } catch {
             case ex: Exception =>
               macroLogVerbose(s"macro runtime failed to load: ${ex.toString}")
@@ -640,31 +408,32 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
 
     import typer.TyperErrorGen._
     val isNullaryArgsEmptyParams = argss.isEmpty && paramss == ListOfNil
-    if (paramss.length < argss.length) MacroTooManyArgumentLists(expandee)
-    if (paramss.length > argss.length && !isNullaryArgsEmptyParams) MacroTooFewArgumentLists(expandee)
+    if (paramss.length < argss.length) MacroTooManyArgumentListsError(expandee)
+    if (paramss.length > argss.length && !isNullaryArgsEmptyParams) MacroTooFewArgumentListsError(expandee)
 
     val macroImplArgs: List[Any] =
       if (fastTrack contains macroDef) {
         // Take a dry run of the fast track implementation
         if (fastTrack(macroDef) validate expandee) argss.flatten
-        else typer.TyperErrorGen.MacroTooFewArgumentLists(expandee)
+        else MacroTooFewArgumentListsError(expandee)
       }
       else {
         val binding = loadMacroImplBinding(macroDef)
-        if (binding.className == Predef_???.owner.fullName.toString && binding.methName == Predef_???.name.encoded) Nil
+        if (binding.className == Predef_???.owner.javaClassName && binding.methName == Predef_???.name.encoded) Nil
         else {
+          val signature = if (binding.isBundle) binding.signature else binding.signature.tail
           macroLogVerbose(s"binding: $binding")
 
           // STEP I: prepare value arguments of the macro expansion
           // wrap argss in c.Expr if necessary (i.e. if corresponding macro impl param is of type c.Expr[T])
           // expand varargs (nb! varargs can apply to any parameter section, not necessarily to the last one)
-          val trees = map3(argss, paramss, binding.signature.tail)((args, defParams, implParams) => {
+          val trees = map3(argss, paramss, signature)((args, defParams, implParams) => {
             val isVarargs = isVarArgsList(defParams)
             if (isVarargs) {
-              if (defParams.length > args.length + 1) MacroTooFewArguments(expandee)
+              if (defParams.length > args.length + 1) MacroTooFewArgumentsError(expandee)
             } else {
-              if (defParams.length < args.length) MacroTooManyArguments(expandee)
-              if (defParams.length > args.length) MacroTooFewArguments(expandee)
+              if (defParams.length < args.length) MacroTooManyArgumentsError(expandee)
+              if (defParams.length > args.length) MacroTooFewArgumentsError(expandee)
             }
 
             val wrappedArgs = mapWithIndex(args)((arg, j) => {
@@ -700,7 +469,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
           // then T and U need to be inferred from the lexical scope of the call using `asSeenFrom`
           // whereas V won't be resolved by asSeenFrom and need to be loaded directly from `expandee` which needs to contain a TypeApply node
           // also, macro implementation reference may contain a regular type as a type argument, then we pass it verbatim
-          val tags = binding.signature.flatten filter (_ >= IMPLPARAM_TAG) map (paramPos => {
+          val tags = signature.flatten filter (_ >= IMPLPARAM_TAG) map (paramPos => {
             val targ = binding.targs(paramPos).tpe.typeSymbol
             val tpe = if (targ.isTypeParameterOrSkolem) {
               if (targ.owner == macroDef) {
diff --git a/src/compiler/scala/tools/nsc/typechecker/StdAttachments.scala b/src/compiler/scala/tools/nsc/typechecker/StdAttachments.scala
index 64fcda3b80..a208924acb 100644
--- a/src/compiler/scala/tools/nsc/typechecker/StdAttachments.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/StdAttachments.scala
@@ -127,4 +127,31 @@ trait StdAttachments {
   /** Determines whether the given tree has an associated SuperArgsAttachment.
    */
   def hasSuperArgs(tree: Tree): Boolean = superArgs(tree).nonEmpty
+
+  /** @see markMacroImplRef
+   */
+  case object MacroImplRefAttachment
+
+  /** Marks the tree as a macro impl reference, which is a naked reference to a method.
+   *
+   *  This is necessary for typechecking macro impl references (see `DefaultMacroCompiler.defaultResolveMacroImpl`),
+   *  because otherwise typing a naked reference will result in the "follow this method with `_' if you want to
+   *  treat it as a partially applied function" errors.
+   *
+   *  This mark suppresses adapt except for when the annottee is a macro application.
+   */
+  def markMacroImplRef(tree: Tree): Tree = tree.updateAttachment(MacroImplRefAttachment)
+
+  /** Unmarks the tree as a macro impl reference (see `markMacroImplRef` for more information).
+   *
+   *  This is necessary when a tree that was previously deemed to be a macro impl reference,
+   *  typechecks to be a macro application. Then we need to unmark it, expand it and try to treat
+   *  its expansion as a macro impl reference.
+   */
+  def unmarkMacroImplRef(tree: Tree): Tree = tree.removeAttachment[MacroImplRefAttachment.type]
+
+  /** Determines whether a tree should or should not be adapted,
+   *  because someone has put MacroImplRefAttachment on it.
+   */
+  def isMacroImplRef(tree: Tree): Boolean = tree.attachments.get[MacroImplRefAttachment.type].isDefined
 }
\ No newline at end of file
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 5916116ef3..c9aa27cf49 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -1234,7 +1234,10 @@ trait Typers extends Adaptations with Tags {
       }
 
       // begin adapt
-      tree.tpe match {
+      if (isMacroImplRef(tree)) {
+        if (treeInfo.isMacroApplication(tree)) adapt(unmarkMacroImplRef(tree), mode, pt, original)
+        else tree
+      } else tree.tpe match {
         case atp @ AnnotatedType(_, _, _) if canAdaptAnnotations(tree, this, mode, pt) => // (-1)
           adaptAnnotations(tree, this, mode, pt)
         case ct @ ConstantType(value) if mode.inNone(TYPEmode | FUNmode) && (ct <:< pt) && canAdaptConstantTypeToLiteral => // (0)
@@ -5534,7 +5537,7 @@ trait Typers extends Adaptations with Tags {
 
       val isMacroBodyOkay = !tree.symbol.isErroneous && !(tree1 exists (_.isErroneous)) && tree1 != EmptyTree
       val shouldInheritMacroImplReturnType = ddef.tpt.isEmpty
-      if (isMacroBodyOkay && shouldInheritMacroImplReturnType) computeMacroDefTypeFromMacroImpl(ddef, macroImplSig(tree1.symbol)) else AnyTpe
+      if (isMacroBodyOkay && shouldInheritMacroImplReturnType) computeMacroDefTypeFromMacroImplRef(ddef, tree1) else AnyTpe
     }
 
     def transformedOr(tree: Tree, op: => Tree): Tree = transformed remove tree match {
diff --git a/src/compiler/scala/tools/reflect/FastTrack.scala b/src/compiler/scala/tools/reflect/FastTrack.scala
index 3cf19396ee..5a0ff4f6db 100644
--- a/src/compiler/scala/tools/reflect/FastTrack.scala
+++ b/src/compiler/scala/tools/reflect/FastTrack.scala
@@ -5,6 +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
 
 /** 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.
diff --git a/src/reflect/scala/reflect/api/Trees.scala b/src/reflect/scala/reflect/api/Trees.scala
index f4ada814af..f7a6a68946 100644
--- a/src/reflect/scala/reflect/api/Trees.scala
+++ b/src/reflect/scala/reflect/api/Trees.scala
@@ -296,6 +296,20 @@ trait Trees { self: Universe =>
     def name: Name
   }
 
+  /** The constructor/extractor for `RefTree` instances.
+   *  @group Extractors
+   */
+  val RefTree: RefTreeExtractor
+
+  /** An extractor class to create and pattern match with syntax `RefTree(qual, name)`.
+   *  This AST node corresponds to either Ident, Select or SelectFromTypeTree.
+   *  @group Extractors
+   */
+  abstract class RefTreeExtractor {
+    def apply(qualifier: Tree, name: Name): RefTree
+    def unapply(refTree: RefTree): Option[(Tree, Name)]
+  }
+
   /** A tree which defines a symbol-carrying entity.
    *  @group Trees
    *  @template
diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala
index 630572464d..5478c54eec 100644
--- a/src/reflect/scala/reflect/internal/Definitions.scala
+++ b/src/reflect/scala/reflect/internal/Definitions.scala
@@ -501,6 +501,13 @@ trait Definitions extends api.StandardDefinitions {
     lazy val OptManifestClass      = requiredClass[scala.reflect.OptManifest[_]]
     lazy val NoManifest            = requiredModule[scala.reflect.NoManifest.type]
 
+    lazy val TreesClass            = getClassIfDefined("scala.reflect.api.Trees") // defined in scala-reflect.jar, so we need to be careful
+    lazy val TreesTreeType         = if (TreesClass != NoSymbol) getTypeMember(TreesClass, tpnme.Tree) else NoSymbol
+    object TreeType {
+      def unapply(tpe: Type): Boolean = unapply(tpe.typeSymbol)
+      def unapply(sym: Symbol): Boolean = sym.overrideChain contains TreesTreeType
+    }
+
     lazy val ExprsClass            = getClassIfDefined("scala.reflect.api.Exprs") // defined in scala-reflect.jar, so we need to be careful
     lazy val ExprClass             = if (ExprsClass != NoSymbol) getMemberClass(ExprsClass, tpnme.Expr) else NoSymbol
          def ExprSplice            = if (ExprsClass != NoSymbol) getMemberMethod(ExprClass, nme.splice) else NoSymbol
@@ -533,6 +540,7 @@ trait Definitions extends api.StandardDefinitions {
     lazy val TypeCreatorClass      = getClassIfDefined("scala.reflect.api.TypeCreator") // defined in scala-reflect.jar, so we need to be careful
     lazy val TreeCreatorClass      = getClassIfDefined("scala.reflect.api.TreeCreator") // defined in scala-reflect.jar, so we need to be careful
 
+    lazy val MacroClass                          = getClassIfDefined("scala.reflect.macros.Macro") // defined in scala-reflect.jar, so we need to be careful
     lazy val MacroContextClass                   = getClassIfDefined("scala.reflect.macros.Context") // defined in scala-reflect.jar, so we need to be careful
          def MacroContextPrefix                  = if (MacroContextClass != NoSymbol) getMemberMethod(MacroContextClass, nme.prefix) else NoSymbol
          def MacroContextPrefixType              = if (MacroContextClass != NoSymbol) getTypeMember(MacroContextClass, tpnme.PrefixType) else NoSymbol
@@ -650,6 +658,12 @@ trait Definitions extends api.StandardDefinitions {
     }
     def isTupleType(tp: Type) = isTupleTypeDirect(tp.dealiasWiden)
 
+    def isMacroBundleType(tp: Type) = {
+      val isNonTrivial = tp != ErrorType && tp != NothingTpe && tp != NullTpe
+      val isMacroCompatible = MacroClass != NoSymbol && tp <:< MacroClass.tpe
+      isNonTrivial && isMacroCompatible
+    }
+
     lazy val ProductRootClass: ClassSymbol = requiredClass[scala.Product]
       def Product_productArity          = getMemberMethod(ProductRootClass, nme.productArity)
       def Product_productElement        = getMemberMethod(ProductRootClass, nme.productElement)
diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala
index a20307882d..81fffc833c 100644
--- a/src/reflect/scala/reflect/internal/StdNames.scala
+++ b/src/reflect/scala/reflect/internal/StdNames.scala
@@ -8,6 +8,7 @@ package reflect
 package internal
 
 import java.security.MessageDigest
+import java.util.UUID.randomUUID
 import Chars.isOperatorPart
 import scala.annotation.switch
 import scala.language.implicitConversions
@@ -290,6 +291,9 @@ trait StdNames {
     val FAKE_LOCAL_THIS: NameType          = "this$"
     val LAZY_LOCAL: NameType               = "$lzy"
     val LAZY_SLOW_SUFFIX: NameType         = "$lzycompute"
+    val MACRO_INVOKER_PACKAGE: NameType    = "scala.reflect.macros.synthetic"
+    // TODO: if I use dollars in MACRO_INVOKER_SUFFIX, as in "$Invoker$", then Scala reflection fails to load implementations
+    val MACRO_INVOKER_SUFFIX: NameType     = "Invoker"
     val UNIVERSE_BUILD_PREFIX: NameType    = "$u.build."
     val UNIVERSE_PREFIX: NameType          = "$u."
     val UNIVERSE_SHORT: NameType           = "$u"
@@ -584,6 +588,7 @@ trait StdNames {
     val box: NameType                  = "box"
     val build : NameType               = "build"
     val bytes: NameType                = "bytes"
+    val c: NameType                    = "c"
     val canEqual_ : NameType           = "canEqual"
     val checkInitialized: NameType     = "checkInitialized"
     val classOf: NameType              = "classOf"
diff --git a/src/reflect/scala/reflect/internal/TreeInfo.scala b/src/reflect/scala/reflect/internal/TreeInfo.scala
index e9ef9c7945..d1e8a04553 100644
--- a/src/reflect/scala/reflect/internal/TreeInfo.scala
+++ b/src/reflect/scala/reflect/internal/TreeInfo.scala
@@ -836,8 +836,17 @@ abstract class TreeInfo {
     }
 
     def unapply(tree: Tree) = refPart(tree) match {
-      case ref: RefTree => Some((ref.qualifier.symbol, ref.symbol, dissectApplied(tree).targs))
-      case _            => None
+      case ref: RefTree => {
+        val isBundle = definitions.isMacroBundleType(ref.qualifier.tpe)
+        val owner =
+          if (isBundle) ref.qualifier.tpe.typeSymbol
+          else {
+            val sym = ref.qualifier.symbol
+            if (sym.isModule) sym.moduleClass else sym
+          }
+        Some((isBundle, owner, ref.symbol, dissectApplied(tree).targs))
+      }
+      case _  => None
     }
   }
 
diff --git a/src/reflect/scala/reflect/internal/Trees.scala b/src/reflect/scala/reflect/internal/Trees.scala
index de0b4e8247..979ee54b4f 100644
--- a/src/reflect/scala/reflect/internal/Trees.scala
+++ b/src/reflect/scala/reflect/internal/Trees.scala
@@ -253,6 +253,19 @@ trait Trees extends api.Trees { self: SymbolTable =>
     def name: Name
   }
 
+  object RefTree extends RefTreeExtractor {
+    def apply(qualifier: Tree, name: Name): RefTree = qualifier match {
+      case EmptyTree =>
+        Ident(name)
+      case qual if qual.isTerm =>
+        Select(qual, name)
+      case qual if qual.isType =>
+        assert(name.isTypeName, s"qual = $qual, name = $name")
+        SelectFromTypeTree(qual, name.toTypeName)
+    }
+    def unapply(refTree: RefTree): Option[(Tree, Name)] = Some((refTree.qualifier, refTree.name))
+  }
+
   abstract class DefTree extends SymTree with NameTree with DefTreeApi {
     def name: Name
     override def isDef = true
diff --git a/src/reflect/scala/reflect/macros/Macro.scala b/src/reflect/scala/reflect/macros/Macro.scala
new file mode 100644
index 0000000000..44bedf483d
--- /dev/null
+++ b/src/reflect/scala/reflect/macros/Macro.scala
@@ -0,0 +1,39 @@
+package scala.reflect
+package macros
+
+/**
+ * <span class="badge badge-red" style="float: right;">EXPERIMENTAL</span>
+ *
+ *  Traditionally macro implementations are defined as methods,
+ *  but this trait provides an alternative way of encoding macro impls as
+ *  bundles, traits which extend `scala.reflect.macros.Macro`.
+ *
+ *  Instead of:
+ *
+ *    def impl[T: c.WeakTypeTag](c: Context)(x: c.Expr[Int]) = ...
+ *
+ *  One can write:
+ *
+ *    trait Impl extends Macro {
+ *      def apply[T: c.WeakTypeTag](x: c.Expr[Int]) = ...
+ *    }
+ *
+ *  Without changing anything else at all.
+ *
+ *  This language feature is useful in itself in cases when macro implementations
+ *  are complex and need to be modularized. State of the art technique of addressing this need is quite heavyweight:
+ *  http://docs.scala-lang.org/overviews/macros/overview.html#writing_bigger_macros.
+ *
+ *  However utility of this approach to writing macros isn't limited to just convenience.
+ *  When a macro implementation becomes not just a function, but a full-fledged module,
+ *  it can define callbacks that will be called by the compiler upon interesting events.
+ *  In subsequent commits I will add support for programmable type inference
+ */
+trait Macro {
+  /** The context to be used by the macro implementation.
+   *
+   *  Vanilla macro implementations have to carry it in their signatures, however when a macro is a full-fledged module,
+   *  it can define the context next to the implementation, makes implementation signature more lightweight.
+   */
+  val c: Context
+}
diff --git a/src/reflect/scala/reflect/runtime/JavaMirrors.scala b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
index adee155db0..a3684f602f 100644
--- a/src/reflect/scala/reflect/runtime/JavaMirrors.scala
+++ b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
@@ -972,8 +972,8 @@ private[reflect] trait JavaMirrors extends internal.SymbolTable with api.JavaUni
             javaTypeToValueClass(jclazz) orElse lookupClass
 
         assert (cls.isType,
-          sm"""${if (cls == NoSymbol) "not a type: symbol" else "no symbol could be"}
-              | loaded from $jclazz in $owner with name $simpleName and classloader $classLoader""")
+          (if (cls != NoSymbol) s"not a type: symbol $cls" else "no symbol could be") +
+          s" loaded from $jclazz in $owner with name $simpleName and classloader $classLoader")
 
         cls.asClass
       }