*boxContext => *box.Context , *boxMacro => *box.Macro

Performs the following renamings:
* scala.reflect.macros.BlackboxContext to scala.reflect.macros.blackbox.Context
* scala.reflect.macros.BlackboxMacro to scala.reflect.macros.blackbox.Macro
* scala.reflect.macros.WhiteboxContext to scala.reflect.macros.whitebox.Context
* scala.reflect.macros.WhiteboxMacro to scala.reflect.macros.whitebox.Macro

https://groups.google.com/forum/#!topic/scala-internals/MX40-dM28rk

4 files changed, 11 insertions, 11 deletions

diff --git a/src/compiler/scala/reflect/macros/compiler/Errors.scala b/src/compiler/scala/reflect/macros/compiler/Errors.scala
index 4c30a9a85c..a408a6ec62 100644
--- a/src/compiler/scala/reflect/macros/compiler/Errors.scala
+++ b/src/compiler/scala/reflect/macros/compiler/Errors.scala
@@ -51,7 +51,7 @@ trait Errors extends Traces {
 
   def MacroBundleNonStaticError() = bundleRefError("macro bundles must be static")
 
-  def MacroBundleWrongShapeError() = bundleRefError("macro bundles must be monomorphic traits extending either BlackboxMacro or WhiteboxMacro and not implementing their `val c: BlackboxContext/WhiteboxContext` member")
+  def MacroBundleWrongShapeError() = bundleRefError("macro bundles must be monomorphic traits extending either blackbox.Macro or whitebox.Macro and not implementing their `val c: Context` member")
 
   // compatibility errors
 
diff --git a/src/compiler/scala/reflect/macros/compiler/Resolvers.scala b/src/compiler/scala/reflect/macros/compiler/Resolvers.scala
index e4851632a5..05daf852ef 100644
--- a/src/compiler/scala/reflect/macros/compiler/Resolvers.scala
+++ b/src/compiler/scala/reflect/macros/compiler/Resolvers.scala
@@ -46,8 +46,8 @@ trait Resolvers {
         if (!isMacroBundleProtoType(bundleProto.tpe)) MacroBundleWrongShapeError()
         if (!bundleProto.owner.isStaticOwner) MacroBundleNonStaticError()
 
-        // synthesize the bundle, i.e. given a static `trait Foo extends Macro { def expand = ... } `
-        // create a top-level definition `class Foo$Bundle(val c: BlackboxContext/WhiteboxContext) extends Foo` in a package next to `Foo`
+        // synthesize the bundle, i.e. given a static `trait Foo extends *box.Macro { def expand = ... } `
+        // create a top-level definition `class Foo$Bundle(val c: *box.Context) extends Foo` in a package next to `Foo`
         val bundlePid = gen.mkUnattributedRef(bundlePkg)
         val bundlePrefix =
           if (bundlePkg == EmptyPackageClass) bundleProto.fullName('$')
diff --git a/src/compiler/scala/reflect/macros/compiler/Validators.scala b/src/compiler/scala/reflect/macros/compiler/Validators.scala
index 5936b52890..95cb0f7466 100644
--- a/src/compiler/scala/reflect/macros/compiler/Validators.scala
+++ b/src/compiler/scala/reflect/macros/compiler/Validators.scala
@@ -93,20 +93,20 @@ trait Validators {
    *
    *  For the following macro impl:
    *    def fooBar[T: c.WeakTypeTag]
-   *           (c: scala.reflect.macros.BlackboxContext)
+   *           (c: scala.reflect.macros.blackbox.Context)
    *           (xs: c.Expr[List[T]])
    *           : c.Expr[T] = ...
    *
    *  This function will return:
-   *    (c: scala.reflect.macros.BlackboxContext)(xs: c.Expr[List[T]])c.Expr[T]
+   *    (c: scala.reflect.macros.blackbox.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 BlackboxMacro/WhiteboxMacro-compatible object,
-   *  then it won't have (c: BlackboxContext/WhiteboxContext) in its parameters, but will rather refer to BlackboxMacro/WhiteboxMacro.c.
+   *  come in different shapes. If the implementation is an apply method of a *box.Macro-compatible object,
+   *  then it won't have (c: *box.Context) in its parameters, but will rather refer to *boxMacro.c.
    *
    *  @param macroImpl The macro implementation symbol
    */
@@ -123,8 +123,8 @@ trait Validators {
    *    def foo[T](xs: List[T]): T = macro fooBar
    *
    *  This function will return:
-   *    (c: scala.reflect.macros.BlackboxContext)(xs: c.Expr[List[T]])c.Expr[T] or
-   *    (c: scala.reflect.macros.WhiteboxContext)(xs: c.Expr[List[T]])c.Expr[T]
+   *    (c: scala.reflect.macros.blackbox.Context)(xs: c.Expr[List[T]])c.Expr[T] or
+   *    (c: scala.reflect.macros.whitebox.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.
diff --git a/src/compiler/scala/reflect/macros/contexts/Context.scala b/src/compiler/scala/reflect/macros/contexts/Context.scala
index 7b79b52a18..87dac18849 100644
--- a/src/compiler/scala/reflect/macros/contexts/Context.scala
+++ b/src/compiler/scala/reflect/macros/contexts/Context.scala
@@ -3,8 +3,8 @@ package contexts
 
 import scala.tools.nsc.Global
 
-abstract class Context extends scala.reflect.macros.BlackboxContext
-                          with scala.reflect.macros.WhiteboxContext
+abstract class Context extends scala.reflect.macros.blackbox.Context
+                          with scala.reflect.macros.whitebox.Context
                           with Aliases
                           with Enclosures
                           with Names