Small change to get rid of naming awkwardness f...

Small change to get rid of naming awkwardness for macros. Class based
macros now have a parameter section (_this: Tree), module based macrod
have an empty pararameter section () instead. So we can let them have
the same name, because overloading resolution will distinguish them
anyway. Review by burmako.

1 files changed, 11 insertions, 10 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
index d0640e76af..99ba0e0971 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
@@ -7,40 +7,41 @@ trait Macros { self: Analyzer =>
   import global._
   import definitions._
 
-  def macroMethName(sym: Symbol) =
-    newTermName((if (sym.name.isTypeName) "type" else "def") + "macro$" +
-                (if (sym.owner.isModuleClass) "obj$" else "cls$") + sym.name)
+  def macroMethName(name: Name) =
+    newTermName((if (name.isTypeName) "type" else "def") + "macro$" + name)
 
   def macroMeth(mac: Symbol): Symbol = {
     var owner = mac.owner
     if (!owner.isModuleClass) owner = owner.companionModule.moduleClass
-    owner.info.decl(macroMethName(mac))
+    owner.info.decl(macroMethName(mac.name))
   }
 
   /**
    * The definition of the method implementing a macro. Example:
-   *  Say we have
+   *  Say we have in a class C
    *
    *    def macro foo[T](xs: List[T]): T = expr
    *
    *  Then the following macro method is generated for `foo`:
    *
-   *    def foo(glob: scala.reflect.api.Universe)
+   *    def defmacro$foo(glob: scala.reflect.api.Universe)
    *           (_this: glob.Tree)
    *           (T: glob.Type)
    *           (xs: glob.Tree): glob.Tree = {
    *      implicit val $glob = glob
    *      expr
    *    }
+   *
+   *    If `foo` is declared in an object, the second parameter list is () instead of (_this: glob.Tree).
    */
   def macroMethDef(mdef: DefDef): Tree = {
     def paramDef(name: Name, tpt: Tree) = ValDef(Modifiers(PARAM), name, tpt, EmptyTree)
     val universeType = TypeTree(ReflectApiUniverse.tpe)
-    val globParam = paramDef("glob", universeType)
+    val globParamSec = List(paramDef("glob", universeType))
     def globSelect(name: Name) = Select(Ident("glob"), name)
     def globTree = globSelect(newTypeName("Tree"))
     def globType = globSelect(newTypeName("Type"))
-    val thisParam = paramDef("_this", globTree)
+    val thisParamSec = if (mdef.symbol.owner.isModuleClass) List() else List(paramDef("_this", globTree))
     def tparamInMacro(tdef: TypeDef) = paramDef(tdef.name.toTermName, globType)
     def vparamInMacro(vdef: ValDef): ValDef = paramDef(vdef.name, globTree)
     def wrapImplicit(tree: Tree) = atPos(tree.pos) {
@@ -50,9 +51,9 @@ trait Macros { self: Analyzer =>
     atPos(mdef.pos) {
       new DefDef( // can't call DefDef here; need to find out why
         mods = mdef.mods &~ MACRO,
-        name = macroMethName(mdef.symbol),
+        name = macroMethName(mdef.name),
         tparams = List(),
-        vparamss = List(globParam) :: List(thisParam) :: (mdef.tparams map tparamInMacro) ::
+        vparamss = globParamSec :: thisParamSec :: (mdef.tparams map tparamInMacro) ::
           (mdef.vparamss map (_ map vparamInMacro)),
         tpt = globTree,
         wrapImplicit(mdef.rhs))