refactors macro runtimes

Following typedMacroBody, macroRuntime along with its friends has also
been moved out into a separate component.

23 files changed, 202 insertions, 122 deletions

diff --git a/src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala b/src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala
index 749e730c0e..32c6da8007 100644
--- a/src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala
+++ b/src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala
@@ -2,7 +2,7 @@ package scala.reflect.macros
 package compiler
 
 import scala.tools.nsc.Global
-import scala.reflect.macros.runtime.Context
+import scala.reflect.macros.contexts.Context
 
 abstract class DefaultMacroCompiler extends Resolvers
                                        with Validators
diff --git a/src/compiler/scala/reflect/macros/runtime/Aliases.scala b/src/compiler/scala/reflect/macros/contexts/Aliases.scala
index 1c6703aeee..cc64d97d85 100644
--- a/src/compiler/scala/reflect/macros/runtime/Aliases.scala
+++ b/src/compiler/scala/reflect/macros/contexts/Aliases.scala
@@ -1,5 +1,5 @@
 package scala.reflect.macros
-package runtime
+package contexts
 
 trait Aliases {
   self: Context =>
diff --git a/src/compiler/scala/reflect/macros/contexts/Context.scala b/src/compiler/scala/reflect/macros/contexts/Context.scala
new file mode 100644
index 0000000000..bd1d7d5248
--- /dev/null
+++ b/src/compiler/scala/reflect/macros/contexts/Context.scala
@@ -0,0 +1,29 @@
+package scala.reflect.macros
+package contexts
+
+import scala.tools.nsc.Global
+
+abstract class Context extends scala.reflect.macros.Context
+                          with Aliases
+                          with Enclosures
+                          with Names
+                          with Reifiers
+                          with FrontEnds
+                          with Infrastructure
+                          with Typers
+                          with Parsers
+                          with Evals
+                          with ExprUtils
+                          with Synthetics
+                          with Traces {
+
+  val universe: Global
+
+  val mirror: universe.Mirror = universe.rootMirror
+
+  val callsiteTyper: universe.analyzer.Typer
+
+  val prefix: Expr[PrefixType]
+
+  val expandee: Tree
+}
diff --git a/src/compiler/scala/reflect/macros/runtime/Enclosures.scala b/src/compiler/scala/reflect/macros/contexts/Enclosures.scala
index f3f92550de..bb88c8d5e1 100644
--- a/src/compiler/scala/reflect/macros/runtime/Enclosures.scala
+++ b/src/compiler/scala/reflect/macros/contexts/Enclosures.scala
@@ -1,5 +1,5 @@
 package scala.reflect.macros
-package runtime
+package contexts
 
 import scala.reflect.{ClassTag, classTag}
 
diff --git a/src/compiler/scala/reflect/macros/runtime/Evals.scala b/src/compiler/scala/reflect/macros/contexts/Evals.scala
index 1f7b5f2ff1..84928ddf86 100644
--- a/src/compiler/scala/reflect/macros/runtime/Evals.scala
+++ b/src/compiler/scala/reflect/macros/contexts/Evals.scala
@@ -1,5 +1,5 @@
 package scala.reflect.macros
-package runtime
+package contexts
 
 import scala.reflect.runtime.{universe => ru}
 import scala.tools.reflect.ToolBox
@@ -7,7 +7,7 @@ import scala.tools.reflect.ToolBox
 trait Evals {
   self: Context =>
 
-  private lazy val evalMirror = ru.runtimeMirror(universe.analyzer.macroClassloader)
+  private lazy val evalMirror = ru.runtimeMirror(universe.analyzer.defaultMacroClassloader)
   private lazy val evalToolBox = evalMirror.mkToolBox()
   private lazy val evalImporter = ru.mkImporter(universe).asInstanceOf[ru.Importer { val from: universe.type }]
 
diff --git a/src/compiler/scala/reflect/macros/runtime/ExprUtils.scala b/src/compiler/scala/reflect/macros/contexts/ExprUtils.scala
index a719beed97..4846325d1e 100644
--- a/src/compiler/scala/reflect/macros/runtime/ExprUtils.scala
+++ b/src/compiler/scala/reflect/macros/contexts/ExprUtils.scala
@@ -1,5 +1,5 @@
 package scala.reflect.macros
-package runtime
+package contexts
 
 trait ExprUtils {
   self: Context =>
diff --git a/src/compiler/scala/reflect/macros/runtime/FrontEnds.scala b/src/compiler/scala/reflect/macros/contexts/FrontEnds.scala
index a6a198e1b4..fda05de09c 100644
--- a/src/compiler/scala/reflect/macros/runtime/FrontEnds.scala
+++ b/src/compiler/scala/reflect/macros/contexts/FrontEnds.scala
@@ -1,5 +1,7 @@
 package scala.reflect.macros
-package runtime
+package contexts
+
+import scala.reflect.macros.runtime.AbortMacroException
 
 trait FrontEnds {
   self: Context =>
diff --git a/src/compiler/scala/reflect/macros/runtime/Infrastructure.scala b/src/compiler/scala/reflect/macros/contexts/Infrastructure.scala
index 7781693822..df7aa4d2be 100644
--- a/src/compiler/scala/reflect/macros/runtime/Infrastructure.scala
+++ b/src/compiler/scala/reflect/macros/contexts/Infrastructure.scala
@@ -1,5 +1,5 @@
 package scala.reflect.macros
-package runtime
+package contexts
 
 trait Infrastructure {
   self: Context =>
diff --git a/src/compiler/scala/reflect/macros/runtime/Names.scala b/src/compiler/scala/reflect/macros/contexts/Names.scala
index 635e8bcd45..e535754a98 100644
--- a/src/compiler/scala/reflect/macros/runtime/Names.scala
+++ b/src/compiler/scala/reflect/macros/contexts/Names.scala
@@ -1,5 +1,5 @@
 package scala.reflect.macros
-package runtime
+package contexts
 
 trait Names {
   self: Context =>
diff --git a/src/compiler/scala/reflect/macros/runtime/Parsers.scala b/src/compiler/scala/reflect/macros/contexts/Parsers.scala
index 566bcde73d..3dab02beba 100644
--- a/src/compiler/scala/reflect/macros/runtime/Parsers.scala
+++ b/src/compiler/scala/reflect/macros/contexts/Parsers.scala
@@ -1,5 +1,5 @@
 package scala.reflect.macros
-package runtime
+package contexts
 
 import scala.language.existentials
 import scala.tools.reflect.ToolBox
diff --git a/src/compiler/scala/reflect/macros/runtime/Reifiers.scala b/src/compiler/scala/reflect/macros/contexts/Reifiers.scala
index 7ec3457c6a..ecef1c7289 100644
--- a/src/compiler/scala/reflect/macros/runtime/Reifiers.scala
+++ b/src/compiler/scala/reflect/macros/contexts/Reifiers.scala
@@ -4,7 +4,7 @@
  */
 
 package scala.reflect.macros
-package runtime
+package contexts
 
 trait Reifiers {
   self: Context =>
diff --git a/src/compiler/scala/reflect/macros/runtime/Synthetics.scala b/src/compiler/scala/reflect/macros/contexts/Synthetics.scala
index 1156769a80..ada16a8113 100644
--- a/src/compiler/scala/reflect/macros/runtime/Synthetics.scala
+++ b/src/compiler/scala/reflect/macros/contexts/Synthetics.scala
@@ -3,7 +3,7 @@
  */
 
 package scala.reflect.macros
-package runtime
+package contexts
 
 import scala.reflect.internal.Flags._
 import scala.reflect.internal.util.BatchSourceFile
diff --git a/src/compiler/scala/reflect/macros/runtime/Traces.scala b/src/compiler/scala/reflect/macros/contexts/Traces.scala
index 0238e9f84e..df47f6ba81 100644
--- a/src/compiler/scala/reflect/macros/runtime/Traces.scala
+++ b/src/compiler/scala/reflect/macros/contexts/Traces.scala
@@ -1,5 +1,5 @@
 package scala.reflect.macros
-package runtime
+package contexts
 
 trait Traces extends util.Traces {
   self: Context =>
diff --git a/src/compiler/scala/reflect/macros/runtime/Typers.scala b/src/compiler/scala/reflect/macros/contexts/Typers.scala
index f92d99a3f2..4a1122b913 100644
--- a/src/compiler/scala/reflect/macros/runtime/Typers.scala
+++ b/src/compiler/scala/reflect/macros/contexts/Typers.scala
@@ -1,5 +1,5 @@
 package scala.reflect.macros
-package runtime
+package contexts
 
 import scala.reflect.internal.Mode
 
diff --git a/src/compiler/scala/reflect/macros/runtime/Context.scala b/src/compiler/scala/reflect/macros/runtime/Context.scala
deleted file mode 100644
index 76c684f6d7..0000000000
--- a/src/compiler/scala/reflect/macros/runtime/Context.scala
+++ /dev/null
@@ -1,29 +0,0 @@
-package scala.reflect.macros
-package runtime
-
-import scala.tools.nsc.Global
-
-abstract class Context extends scala.reflect.macros.Context
-                         with Aliases
-                         with Enclosures
-                         with Names
-                         with Reifiers
-                         with FrontEnds
-                         with Infrastructure
-                         with Typers
-                         with Parsers
-                         with Evals
-                         with ExprUtils
-                         with Synthetics
-                         with Traces {
-
-  val universe: Global
-
-  val mirror: universe.Mirror = universe.rootMirror
-
-  val callsiteTyper: universe.analyzer.Typer
-
-  val prefix: Expr[PrefixType]
-
-  val expandee: Tree
-}
diff --git a/src/compiler/scala/reflect/macros/runtime/JavaReflectionRuntimes.scala b/src/compiler/scala/reflect/macros/runtime/JavaReflectionRuntimes.scala
new file mode 100644
index 0000000000..3ef11fad9d
--- /dev/null
+++ b/src/compiler/scala/reflect/macros/runtime/JavaReflectionRuntimes.scala
@@ -0,0 +1,31 @@
+package scala.reflect.macros
+package runtime
+
+import scala.reflect.runtime.ReflectionUtils
+import scala.reflect.macros.{Context => ApiContext}
+
+trait JavaReflectionRuntimes {
+  self: scala.tools.nsc.typechecker.Analyzer =>
+
+  trait JavaReflectionResolvers {
+    self: MacroRuntimeResolver =>
+
+    import global._
+
+    def resolveJavaReflectionRuntime(classLoader: ClassLoader): MacroRuntime = {
+      val implClass = Class.forName(className, true, classLoader)
+      val implMeths = implClass.getDeclaredMethods.find(_.getName == methName)
+      // relies on the fact that macro impls cannot be overloaded
+      // so every methName can resolve to at maximum one method
+      val implMeth = implMeths getOrElse { throw new NoSuchMethodException(s"$className.$methName") }
+      macroLogVerbose(s"successfully loaded macro impl as ($implClass, $implMeth)")
+      args => {
+        val implObj =
+          if (isBundle) implClass.getConstructor(classOf[ApiContext]).newInstance(args.c)
+          else ReflectionUtils.staticSingletonInstance(implClass)
+        val implArgs = if (isBundle) args.others else args.c +: args.others
+        implMeth.invoke(implObj, implArgs.asInstanceOf[Seq[AnyRef]]: _*)
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/compiler/scala/reflect/macros/runtime/MacroRuntimes.scala b/src/compiler/scala/reflect/macros/runtime/MacroRuntimes.scala
new file mode 100644
index 0000000000..0f89163803
--- /dev/null
+++ b/src/compiler/scala/reflect/macros/runtime/MacroRuntimes.scala
@@ -0,0 +1,74 @@
+package scala.reflect.macros
+package runtime
+
+import scala.collection.mutable.{Map => MutableMap}
+import scala.reflect.internal.Flags._
+import scala.reflect.runtime.ReflectionUtils
+import scala.tools.nsc.util.ScalaClassLoader
+import scala.tools.nsc.util.AbstractFileClassLoader
+
+trait MacroRuntimes extends JavaReflectionRuntimes with ScalaReflectionRuntimes {
+  self: scala.tools.nsc.typechecker.Analyzer =>
+
+  import global._
+  import definitions._
+
+  /** 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.
+   *    3) Loads the companion of that enclosing class from the macro classloader.
+   *    4) Resolves macro implementation within the loaded companion.
+   *
+   *  @return Requested runtime if macro implementation can be loaded successfully from either of the mirrors,
+   *          `null` otherwise.
+   */
+  private val macroRuntimesCache = perRunCaches.newWeakMap[Symbol, MacroRuntime]
+  def macroRuntime(macroDef: Symbol): MacroRuntime = {
+    macroLogVerbose(s"looking for macro implementation: $macroDef")
+    if (fastTrack contains macroDef) {
+      macroLogVerbose("macro expansion is serviced by a fast track")
+      fastTrack(macroDef)
+    } else {
+      macroRuntimesCache.getOrElseUpdate(macroDef, new MacroRuntimeResolver(macroDef).resolveRuntime())
+    }
+  }
+
+  /** Macro classloader that is used to resolve and run macro implementations.
+   *  Loads classes from from -cp (aka the library classpath).
+   *  Is also capable of detecting REPL and reusing its classloader.
+   *
+   *  When -Xmacro-jit is enabled, we sometimes fallback to on-the-fly compilation of macro implementations,
+   *  which compiles implementations into a virtual directory (very much like REPL does) and then conjures
+   *  a classloader mapped to that virtual directory.
+   */
+  lazy val defaultMacroClassloader: ClassLoader = findMacroClassLoader()
+
+  /** Abstracts away resolution of macro runtimes.
+   */
+  type MacroRuntime = MacroArgs => Any
+  class MacroRuntimeResolver(val macroDef: Symbol) extends JavaReflectionResolvers
+                                                      with ScalaReflectionResolvers {
+    val binding = loadMacroImplBinding(macroDef)
+    val isBundle = binding.isBundle
+    val className = binding.className
+    val methName = binding.methName
+
+    def resolveRuntime(): MacroRuntime = {
+      if (className == Predef_???.owner.javaClassName && methName == Predef_???.name.encoded) {
+        args => throw new AbortMacroException(args.c.enclosingPosition, "macro implementation is missing")
+      } else {
+        try {
+          macroLogVerbose(s"resolving macro implementation as $className.$methName (isBundle = $isBundle)")
+          macroLogVerbose(s"classloader is: ${ReflectionUtils.show(defaultMacroClassloader)}")
+          // resolveScalaReflectionRuntime(defaultMacroClassloader)
+          resolveJavaReflectionRuntime(defaultMacroClassloader)
+        } catch {
+          case ex: Exception =>
+            macroLogVerbose(s"macro runtime failed to load: ${ex.toString}")
+            macroDef setFlag IS_ERROR
+            null
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/compiler/scala/reflect/macros/runtime/ScalaReflectionRuntimes.scala b/src/compiler/scala/reflect/macros/runtime/ScalaReflectionRuntimes.scala
new file mode 100644
index 0000000000..1999e525ff
--- /dev/null
+++ b/src/compiler/scala/reflect/macros/runtime/ScalaReflectionRuntimes.scala
@@ -0,0 +1,33 @@
+package scala.reflect.macros
+package runtime
+
+import scala.reflect.runtime.{universe => ru}
+
+trait ScalaReflectionRuntimes {
+  self: scala.tools.nsc.typechecker.Analyzer =>
+
+  trait ScalaReflectionResolvers {
+    self: MacroRuntimeResolver =>
+
+    import global._
+
+    def resolveScalaReflectionRuntime(classLoader: ClassLoader): MacroRuntime = {
+      val macroMirror: ru.JavaMirror = ru.runtimeMirror(classLoader)
+      val implContainerSym = macroMirror.classSymbol(Class.forName(className, true, classLoader))
+      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: _*)
+      }
+    }
+  }
+}
diff --git a/src/compiler/scala/reflect/macros/runtime/package.scala b/src/compiler/scala/reflect/macros/runtime/package.scala
new file mode 100644
index 0000000000..9ef8200760
--- /dev/null
+++ b/src/compiler/scala/reflect/macros/runtime/package.scala
@@ -0,0 +1,5 @@
+package scala.reflect.macros
+
+package object runtime {
+  type Context = scala.reflect.macros.contexts.Context
+}
\ No newline at end of file
diff --git a/src/compiler/scala/reflect/reify/Taggers.scala b/src/compiler/scala/reflect/reify/Taggers.scala
index 9659134e5b..0bffe55403 100644
--- a/src/compiler/scala/reflect/reify/Taggers.scala
+++ b/src/compiler/scala/reflect/reify/Taggers.scala
@@ -1,7 +1,7 @@
 package scala.reflect.reify
 
 import scala.reflect.macros.{ReificationException, UnexpectedReificationException, TypecheckException}
-import scala.reflect.macros.runtime.Context
+import scala.reflect.macros.contexts.Context
 
 abstract class Taggers {
   val c: Context
diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
index 40f284c94c..8d650b3653 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
@@ -10,9 +10,10 @@ import scala.reflect.ClassTag
 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.macros.runtime.{AbortMacroException, MacroRuntimes}
 import scala.reflect.runtime.{universe => ru}
 import scala.reflect.macros.compiler.DefaultMacroCompiler
+import scala.tools.reflect.FastTrack
 
 /**
  *  Code to deal with macros, namely with:
@@ -39,7 +40,7 @@ import scala.reflect.macros.compiler.DefaultMacroCompiler
  *    (Expr(elems))
  *    (TypeTag(Int))
  */
-trait Macros extends scala.tools.reflect.FastTrack with Traces with Helpers {
+trait Macros extends FastTrack with MacroRuntimes with Traces with Helpers {
   self: Analyzer =>
 
   import global._
@@ -77,7 +78,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces with Helpers {
    *  Includes a path to load the implementation via Java reflection,
    *  and various accounting information necessary when composing an argument list for the reflective invocation.
    */
-  private case class MacroImplBinding(
+  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
@@ -99,9 +100,9 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces with Helpers {
     // these trees don't refer to a macro impl, so we can pickle them as is
     targs: List[Tree])
 
-  private final val IMPLPARAM_TAG = 0 // actually it's zero and above, this is just a lower bound for >= checks
-  private final val IMPLPARAM_OTHER = -1
-  private final val IMPLPARAM_EXPR = -2
+  final val IMPLPARAM_TAG = 0 // actually it's zero and above, this is just a lower bound for >= checks
+  final val IMPLPARAM_OTHER = -1
+  final val IMPLPARAM_EXPR = -2
 
   /** Macro def -> macro impl bindings are serialized into a `macroImpl` annotation
    *  with synthetic content that carries the payload described in `MacroImplBinding`.
@@ -120,7 +121,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces with Helpers {
    *        "versionFormat" = <current version format>,
    *        "className" = "Macros$"))
    */
-  private object MacroImplBinding {
+  object MacroImplBinding {
     val versionFormat = 3
 
     def pickleAtom(obj: Any): Tree =
@@ -220,12 +221,12 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces with Helpers {
     }
   }
 
-  private def bindMacroImpl(macroDef: Symbol, macroImplRef: Tree): Unit = {
+  def bindMacroImpl(macroDef: Symbol, macroImplRef: Tree): Unit = {
     val pickle = MacroImplBinding.pickle(macroImplRef)
     macroDef withAnnotation AnnotationInfo(MacroImplAnnotation.tpe, List(pickle), Nil)
   }
 
-  private def loadMacroImplBinding(macroDef: Symbol): MacroImplBinding = {
+  def loadMacroImplBinding(macroDef: Symbol): MacroImplBinding = {
     val Some(AnnotationInfo(_, List(pickle), _)) = macroDef.getAnnotation(MacroImplAnnotation)
     MacroImplBinding.unpickle(pickle)
   }
@@ -309,73 +310,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces with Helpers {
     }
   }
 
-  /** Macro classloader that is used to resolve and run macro implementations.
-   *  Loads classes from from -cp (aka the library classpath).
-   *  Is also capable of detecting REPL and reusing its classloader.
-   */
-  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.
-   *    3) Loads the companion of that enclosing class from the macro classloader.
-   *    4) Resolves macro implementation within the loaded companion.
-   *
-   *  @return Requested runtime if macro implementation can be loaded successfully from either of the mirrors,
-   *          `null` otherwise.
-   */
-  type MacroRuntime = MacroArgs => Any
-  private val macroRuntimesCache = perRunCaches.newWeakMap[Symbol, MacroRuntime]()
-  private def macroRuntime(macroDef: Symbol): MacroRuntime = {
-    macroLogVerbose(s"looking for macro implementation: $macroDef")
-    if (fastTrack contains macroDef) {
-      macroLogVerbose("macro expansion is serviced by a fast track")
-      fastTrack(macroDef)
-    } 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.javaClassName && binding.methName == Predef_???.name.encoded) {
-          args => throw new AbortMacroException(args.c.enclosingPosition, "macro implementation is missing")
-        } else {
-          try {
-            macroLogVerbose(s"loading implementation class: $className")
-            macroLogVerbose(s"classloader is: ${ReflectionUtils.show(macroClassloader)}")
-            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}")
-              macroDef setFlag IS_ERROR
-              null
-          }
-        }
-      })
-    }
-  }
-
-  private def macroContext(typer: Typer, prefixTree: Tree, expandeeTree: Tree): MacroContext = {
+  def macroContext(typer: Typer, prefixTree: Tree, expandeeTree: Tree): MacroContext = {
     new {
       val universe: self.global.type = self.global
       val callsiteTyper: universe.analyzer.Typer = typer.asInstanceOf[global.analyzer.Typer]
diff --git a/src/compiler/scala/tools/nsc/typechecker/StdAttachments.scala b/src/compiler/scala/tools/nsc/typechecker/StdAttachments.scala
index a208924acb..c616ded704 100644
--- a/src/compiler/scala/tools/nsc/typechecker/StdAttachments.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/StdAttachments.scala
@@ -10,7 +10,7 @@ trait StdAttachments {
    *  At times we need to store this info, because macro expansion can be delayed until its targs are inferred.
    *  After a macro application has been successfully expanded, this attachment is destroyed.
    */
-  type UnaffiliatedMacroContext = scala.reflect.macros.runtime.Context
+  type UnaffiliatedMacroContext = scala.reflect.macros.contexts.Context
   type MacroContext = UnaffiliatedMacroContext { val universe: self.global.type }
   case class MacroRuntimeAttachment(delayed: Boolean, typerContext: Context, macroContext: Option[MacroContext])
 
diff --git a/src/compiler/scala/tools/reflect/MacroImplementations.scala b/src/compiler/scala/tools/reflect/MacroImplementations.scala
index 109c148b7e..8e1bcb5f87 100644
--- a/src/compiler/scala/tools/reflect/MacroImplementations.scala
+++ b/src/compiler/scala/tools/reflect/MacroImplementations.scala
@@ -1,6 +1,6 @@
 package scala.tools.reflect
 
-import scala.reflect.macros.runtime.Context
+import scala.reflect.macros.contexts.Context
 import scala.collection.mutable.ListBuffer
 import scala.collection.mutable.Stack
 import scala.reflect.internal.util.OffsetPosition