adds c.macroRole

Currently there's only one flavor of macros - def macros, and the plan
was to gradually introduce additional flavors, such as type macros and
macro annotations.

However as shown by the experience with type macros, it makes sense
to distinguish subflavors of macros that tell us in which context the
macro gets expanded. For def macros we have the only role - expansion
of an application. But for type macros there are multiple.

3 files changed, 24 insertions, 0 deletions

diff --git a/src/compiler/scala/reflect/macros/runtime/Enclosures.scala b/src/compiler/scala/reflect/macros/runtime/Enclosures.scala
index e8b2961611..8fe0b09700 100644
--- a/src/compiler/scala/reflect/macros/runtime/Enclosures.scala
+++ b/src/compiler/scala/reflect/macros/runtime/Enclosures.scala
@@ -8,6 +8,10 @@ trait Enclosures {
 
   import universe._
 
+  type MacroRole = analyzer.MacroRole
+  def APPLY_ROLE = analyzer.APPLY_ROLE
+  def macroRole: MacroRole
+
   private lazy val site       = callsiteTyper.context
   private lazy val enclTrees  = site.enclosingContextChain map (_.tree)
   private lazy val enclPoses  = enclosingMacros map (_.macroApplication.pos) filterNot (_ eq NoPosition)
diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
index 768d739b4b..23e00960d4 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
@@ -538,6 +538,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
       val universe: self.global.type = self.global
       val callsiteTyper: universe.analyzer.Typer = typer.asInstanceOf[global.analyzer.Typer]
       val expandee = expandeeTree
+      val macroRole = APPLY_ROLE
     } with UnaffiliatedMacroContext {
       val prefix = Expr[Nothing](prefixTree)(TypeTag.Nothing)
       override def toString = "MacroContext(%s@%s +%d)".format(expandee.symbol.name, expandee.pos, enclosingMacros.length - 1 /* exclude myself */)
@@ -645,6 +646,12 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
   private def popMacroContext() = _openMacros = _openMacros.tail
   def enclosingMacroPosition = openMacros map (_.macroApplication.pos) find (_ ne NoPosition) getOrElse NoPosition
 
+  /** Describes the role that the macro expandee is performing.
+   */
+  type MacroRole = String
+  final def APPLY_ROLE: MacroRole = "APPLY_ROLE"
+  private val roleNames = Map(APPLY_ROLE -> "apply")
+
   private sealed abstract class MacroExpansionResult
   private case class Success(expanded: Tree) extends MacroExpansionResult
   private case class Fallback(fallback: Tree) extends MacroExpansionResult { currentRun.seenMacroExpansionsFallingBack = true }
diff --git a/src/reflect/scala/reflect/macros/Enclosures.scala b/src/reflect/scala/reflect/macros/Enclosures.scala
index 1e366ccbc3..723b94016d 100644
--- a/src/reflect/scala/reflect/macros/Enclosures.scala
+++ b/src/reflect/scala/reflect/macros/Enclosures.scala
@@ -17,6 +17,19 @@ trait Enclosures {
    */
   def macroApplication: Tree
 
+  /** The semantic role that `macroApplication` plays in the code.
+   */
+  type MacroRole
+
+  /** The role that represents an application of a term macro,
+   *  e.g. `M(2)(3)` in `val x = M(2)(3)` or `M(a, b)` in `x match { case x @ M(a, b) => }`.
+   */
+  def APPLY_ROLE: MacroRole
+
+  /** The semantic role that `macroApplication` plays in the code.
+   */
+  def macroRole: MacroRole
+
   /** Contexts that represent macros in-flight, including the current one. Very much like a stack trace, but for macros only.
    *  Can be useful for interoperating with other macros and for imposing compiler-friendly limits on macro expansion.
    *