Remove Macro flag for splice macros

The Macro flag is now only for Scala 2 macros

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/Flags.scala

@@ -407,7 +407,7 @@ object Flags {
   /** A Scala 2.12 or higher trait */
   final val Scala_2_12_Trait = typeFlag(58, "<scala_2_12_trait>")
 
-  /** A macro */
+  /** A Scala 2 macro */
   final val Macro = commonFlag(59, "<macro>")
 
   /** A method that is known to have inherited default parameters */
@@ -608,9 +608,6 @@ object Flags {
   /** Is a default parameter in Scala 2*/
   final val DefaultParameter = allOf(Param, DefaultParameterized)
 
-  /** A Scala 2 Macro */
-  final val Scala2Macro = allOf(Macro, Scala2x)
-
   /** A trait that does not need to be initialized */
   final val NoInitsTrait = allOf(Trait, NoInits)
 

compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala

@@ -583,7 +583,7 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
     val abs = sym.is(Abstract) || sym.is(Deferred) || absOver
     val over = sym.is(Override) || absOver
     new api.Modifiers(abs, over, sym.is(Final), sym.is(Sealed),
-      sym.is(Implicit), sym.is(Lazy), sym.is(Macro), sym.isSuperAccessor)
+      sym.is(Implicit), sym.is(Lazy), false, sym.isSuperAccessor)
   }
 
   def apiAnnotations(s: Symbol): List[api.Annotation] = {

compiler/src/dotty/tools/dotc/tastyreflect/FlagSet.scala

@@ -15,7 +15,6 @@ class FlagSet(flags: Flags.FlagSet) extends scala.tasty.FlagSet {
   def isLazy: Boolean = flags.is(Lazy)
   def isOverride: Boolean = flags.is(Override)
   def isTransparent: Boolean = flags.is(Transparent)
-  def isMacro: Boolean = flags.is(Macro)
   def isStatic: Boolean = flags.is(JavaStatic)
   def isObject: Boolean = flags.is(Module)
   def isTrait: Boolean = flags.is(Trait)
@@ -46,7 +45,6 @@ class FlagSet(flags: Flags.FlagSet) extends scala.tasty.FlagSet {
     if (isLazy) flags += "lazy"
     if (isOverride) flags += "override"
     if (isTransparent) flags += "transparent"
-    if (isMacro) flags += "macro"
     if (isStatic) flags += "javaStatic"
     if (isObject) flags += "object"
     if (isTrait) flags += "trait"

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -165,10 +165,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
 
       def markAsMacro(c: Context): Unit =
         if (c.owner eq c.outer.owner) markAsMacro(c.outer)
-        else if (c.owner.isTransparentMethod) {
-          c.owner.setFlag(Macro)
-          c.owner.resetFlag(Erased) // FIXME: Macros should be Erased, but that causes problems right now
-        }
+        else if (c.owner.isTransparentMethod) () // OK
         else if (!c.outer.owner.is(Package)) markAsMacro(c.outer)
 
       if (sym.isSplice || sym.isQuote) {

compiler/src/dotty/tools/dotc/transform/ValueClasses.scala

@@ -28,8 +28,7 @@ object ValueClasses {
       d.isRealMethod &&
       isDerivedValueClass(d.owner) &&
       !d.isConstructor &&
-      !d.isSuperAccessor &&
-      !d.is(Macro)
+      !d.isSuperAccessor
     }
 
   /** The member of a derived value class that unboxes it. */

compiler/src/dotty/tools/dotc/typer/RefChecks.scala

@@ -143,9 +143,8 @@ object RefChecks {
    *    1.8.1  M's type is a subtype of O's type, or
    *    1.8.2  M is of type []S, O is of type ()T and S <: T, or
    *    1.8.3  M is of type ()S, O is of type []T and S <: T, or
-   *    1.9    M must not be a typelevel def or a Dotty macro def
+   *    1.9    M must not be a typelevel def
    *    1.10.  If M is a 2.x macro def, O cannot be deferred unless there's a concrete method overriding O.
-   *    1.11.  If M is not a macro def, O cannot be a macro def.
    *  2. Check that only abstract classes have deferred members
    *  3. Check that concrete classes do not have deferred definitions
    *     that are not implemented in a subclass.
@@ -378,12 +377,8 @@ object RefChecks {
         overrideError("must be declared lazy to override a lazy value")
       } else if (member.is(Erased) && member.allOverriddenSymbols.forall(_.is(Deferred))) { // (1.9)
         overrideError("is an erased method, may not override only deferred methods")
-      } else if (member.is(Macro, butNot = Scala2x)) { // (1.9)
-        overrideError("is a macro, may not override anything")
-      } else if (other.is(Deferred) && member.is(Scala2Macro) && member.extendedOverriddenSymbols.forall(_.is(Deferred))) { // (1.10)
+      } else if (other.is(Deferred) && member.is(Macro) && member.extendedOverriddenSymbols.forall(_.is(Deferred))) { // (1.10)
         overrideError("cannot be used here - term macros cannot override abstract methods")
-      } else if (other.is(Macro) && !member.is(Macro)) { // (1.11)
-        overrideError("cannot be used here - only term macros can override term macros")
       } else if (!compatibleTypes(memberTp(self), otherTp(self)) &&
                  !compatibleTypes(memberTp(upwardsSelf), otherTp(upwardsSelf))) {
         overrideError("has incompatible type" + err.whyNoMatchStr(memberTp(self), otherTp(self)))

library/src/scala/tasty/FlagSet.scala

@@ -11,7 +11,6 @@ trait FlagSet {
   def isLazy: Boolean
   def isOverride: Boolean
   def isTransparent: Boolean
-  def isMacro: Boolean                 // transparent method containing toplevel splices
   def isStatic: Boolean                // mapped to static Java member
   def isObject: Boolean                // an object or its class (used for a ValDef or a ClassDef extends Modifier respectively)
   def isTrait: Boolean                 // a trait (used for a ClassDef)