changes bundles to be classes, not traits extending Macro

Adjusts bundle notation to read `class Bundle(val c: Context)` instead of
`class Bundle extends Macro`. This avoids calling compileLate in the
macro compiler and associated tooling problems.

4 files changed, 11 insertions, 36 deletions

diff --git a/src/compiler/scala/reflect/macros/compiler/Errors.scala b/src/compiler/scala/reflect/macros/compiler/Errors.scala
index a408a6ec62..6b6d4248aa 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 blackbox.Macro or whitebox.Macro and not implementing their `val c: Context` member")
+  def MacroBundleWrongShapeError() = bundleRefError("macro bundles must be concrete classes having a single `val c: Context` parameter")
 
   // compatibility errors
 
diff --git a/src/compiler/scala/reflect/macros/compiler/Resolvers.scala b/src/compiler/scala/reflect/macros/compiler/Resolvers.scala
index 05daf852ef..d35f1c32a9 100644
--- a/src/compiler/scala/reflect/macros/compiler/Resolvers.scala
+++ b/src/compiler/scala/reflect/macros/compiler/Resolvers.scala
@@ -40,36 +40,11 @@ trait Resolvers {
     }
 
     val untypedImplRef = typer.silent(_.typedTypeConstructor(maybeBundleRef)) match {
-      case SilentResultValue(result) if mightBeMacroBundleType(result.tpe) =>
-        val bundleProto = result.tpe.typeSymbol
-        val bundlePkg = bundleProto.enclosingPackageClass
-        if (!isMacroBundleProtoType(bundleProto.tpe)) MacroBundleWrongShapeError()
-        if (!bundleProto.owner.isStaticOwner) MacroBundleNonStaticError()
-
-        // 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('$')
-          else bundleProto.fullName('$').substring(bundlePkg.fullName('$').length + 1)
-        val bundleName = TypeName(bundlePrefix + tpnme.MACRO_BUNDLE_SUFFIX)
-        val existingBundle = bundleProto.enclosingPackageClass.info.decl(bundleName)
-        if (!currentRun.compiles(existingBundle)) {
-          val contextType = if (isBlackboxMacroBundleType(bundleProto.tpe)) BlackboxContextClass.tpe else WhiteboxContextClass.tpe
-          def mkContextValDef(flags: Long) = ValDef(Modifiers(flags), nme.c, TypeTree(contextType), EmptyTree)
-          val contextField = mkContextValDef(PARAMACCESSOR)
-          val contextParam = mkContextValDef(PARAM | PARAMACCESSOR)
-          val bundleCtor = DefDef(Modifiers(), nme.CONSTRUCTOR, Nil, List(List(contextParam)), TypeTree(), Block(List(pendingSuperCall), Literal(Constant(()))))
-          val bundleParent = gen.mkAppliedTypeTree(Ident(bundleProto), bundleProto.typeParams.map(sym => Ident(sym.name)))
-          val bundleTemplate = Template(List(bundleParent), noSelfType, List(contextField, bundleCtor))
-          val bundle = atPos(bundleProto.pos)(ClassDef(NoMods, bundleName, bundleProto.typeParams.map(TypeDef(_)), bundleTemplate))
-          currentRun.compileLate(bundleName + ".scala", PackageDef(bundlePid, List(bundle)))
-        }
-
-        // synthesize the macro impl reference, which is going to look like:
-        // `new FooBundle(???).macroName` plus the optional type arguments
-        val bundleInstance = New(Select(bundlePid, bundleName), List(List(Ident(Predef_???))))
-        atPos(macroDdef.rhs.pos)(gen.mkTypeApply(Select(bundleInstance, methName), targs))
+      case SilentResultValue(result) if looksLikeMacroBundleType(result.tpe) =>
+        val bundle = result.tpe.typeSymbol
+        if (!isMacroBundleType(bundle.tpe)) MacroBundleWrongShapeError()
+        if (!bundle.owner.isStaticOwner) MacroBundleNonStaticError()
+        atPos(macroDdef.rhs.pos)(gen.mkTypeApply(Select(New(bundle, Ident(Predef_???)), methName), targs))
       case _ =>
         macroDdef.rhs
     }
diff --git a/src/compiler/scala/reflect/macros/compiler/Validators.scala b/src/compiler/scala/reflect/macros/compiler/Validators.scala
index 95cb0f7466..02c1f7c431 100644
--- a/src/compiler/scala/reflect/macros/compiler/Validators.scala
+++ b/src/compiler/scala/reflect/macros/compiler/Validators.scala
@@ -26,9 +26,9 @@ trait Validators {
     if (macroImpl.isOverloaded) MacroImplOverloadedError()
     val implicitParams = aparamss.flatten filter (_.isImplicit)
     if (implicitParams.nonEmpty) MacroImplNonTagImplicitParameters(implicitParams)
-    val declaredInStaticObject = isImplMethod && (macroImplOwner.isStaticOwner || macroImplOwner.moduleClass.isStaticOwner)
-    val declaredInTopLevelClass = isImplBundle && macroImplOwner.owner.isPackageClass
-    if (!declaredInStaticObject && !declaredInTopLevelClass) MacroImplReferenceWrongShapeError()
+    val effectiveOwner = if (isImplMethod) macroImplOwner else macroImplOwner.owner
+    val declaredInStaticObject = effectiveOwner.isStaticOwner || effectiveOwner.moduleClass.isStaticOwner
+    if (!declaredInStaticObject) MacroImplReferenceWrongShapeError()
   }
 
   private def checkMacroDefMacroImplCorrespondence() = {
diff --git a/src/compiler/scala/reflect/macros/runtime/JavaReflectionRuntimes.scala b/src/compiler/scala/reflect/macros/runtime/JavaReflectionRuntimes.scala
index 450cb4d9ea..8ad38ff5f0 100644
--- a/src/compiler/scala/reflect/macros/runtime/JavaReflectionRuntimes.scala
+++ b/src/compiler/scala/reflect/macros/runtime/JavaReflectionRuntimes.scala
@@ -2,7 +2,7 @@ package scala.reflect.macros
 package runtime
 
 import scala.reflect.runtime.ReflectionUtils
-import scala.reflect.macros.{Context => ApiContext}
+import scala.reflect.macros.blackbox.{Context => ApiContext}
 
 trait JavaReflectionRuntimes {
   self: scala.tools.nsc.typechecker.Analyzer =>
@@ -19,7 +19,7 @@ trait JavaReflectionRuntimes {
       macroLogVerbose(s"successfully loaded macro impl as ($implClass, $implMeth)")
       args => {
         val implObj =
-          if (isBundle) implClass.getConstructor(classOf[ApiContext]).newInstance(args.c)
+          if (isBundle) implClass.getConstructors().head.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]]: _*)