Eliminate macros in RefChecks

... after checking that they do not override anything.
This means we do not need to transform their bodies in ReifyQuotes.

Author: odersky

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

@@ -598,6 +598,9 @@ 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/transform/ReifyQuotes.scala

@@ -16,8 +16,6 @@ import NameKinds.OuterSelectName
 import scala.collection.mutable
 
 // TODO
-//   check that inline methods override nothing
-//   drop inline methods
 //   adapt to Expr/Type when passing arguments to splices
 
 /** Translates quoted terms and types to `unpickle` method calls.
@@ -175,12 +173,9 @@ class ReifyQuotes extends MacroTransform {
       case _ =>
     }
 
-    /** Are we in the body of an inline method? */
-    def inInline(implicit ctx: Context) = ctx.owner.ownersIterator.exists(_.isInlineMethod)
-
     /** Issue a "splice outside quote" error unless we ar in the body of an inline method */
     def spliceOutsideQuotes(pos: Position)(implicit ctx: Context) =
-      if (!inInline) ctx.error(i"splice outside quotes", pos)
+      ctx.error(i"splice outside quotes", pos)
 
     /** Check reference to `sym` for phase consistency, where `tp` is the underlying type
      *  by which we refer to `sym`.
@@ -193,8 +188,7 @@ class ReifyQuotes extends MacroTransform {
         else i"${sym.name}.this"
       if (!isThis && sym.maybeOwner.isType)
         check(sym.owner, sym.owner.thisType, pos)
-      else if (sym.exists && !sym.isStaticOwner && !inInline &&
-              levelOf.getOrElse(sym, level) != level)
+      else if (sym.exists && !sym.isStaticOwner && levelOf.getOrElse(sym, level) != level)
         tp match {
           case tp: TypeRef =>
             importedTypes += tp
@@ -288,8 +282,7 @@ class ReifyQuotes extends MacroTransform {
       }
       else {
         spliceOutsideQuotes(splice.pos)
-        if (splice.isType) TypeTree(splice.tpe.dealias)
-        else transform(body).select(defn.QuotedExpr_run)
+        splice
       }
     }.withPos(splice.pos)
 
@@ -336,6 +329,8 @@ class ReifyQuotes extends MacroTransform {
             cpy.Select(expansion)(cpy.Inlined(tree)(call, bindings, body), name)
           case _: Import =>
             tree
+          case tree: DefDef if tree.symbol.is(Macro) =>
+            cpy.DefDef(tree)(rhs = EmptyTree)
           case _ =>
             markDef(tree)
             checkLevel(mapOverTree(enteredSyms))

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

@@ -375,7 +375,8 @@ class TreeChecker extends Phase with SymTransformer {
       def isNonMagicalMethod(x: Symbol) =
         x.is(Method) &&
           !x.isCompanionMethod &&
-          !x.isValueClassConvertMethod
+          !x.isValueClassConvertMethod &&
+          !(x.is(Macro) && ctx.phase.refChecked)
 
       val symbolsNotDefined = cls.classInfo.decls.toList.toSet.filter(isNonMagicalMethod) -- impl.body.map(_.symbol) - constr.symbol
 

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

@@ -130,7 +130,7 @@ object RefChecks {
    *  That is for overriding member M and overridden member O:
    *
    *    1.1. M must have the same or stronger access privileges as O.
-   *    1.2. O must not be final.
+   *    1.2. O must not be effectively final.
    *    1.3. O is deferred, or M has `override` modifier.
    *    1.4. If O is stable, then so is M.
    *     // @M: LIFTED 1.5. Neither M nor O are a parameterized type alias
@@ -144,8 +144,9 @@ 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.  If M is a macro def, O cannot be deferred unless there's a concrete method overriding O.
-   *    1.10. If M is not a macro def, O cannot be a macro def.
+   *    1.9    M must not be a Dotty macro 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.
@@ -372,9 +373,11 @@ object RefChecks {
         overrideError("may not override a non-lazy value")
       } else if (other.is(Lazy) && !other.isRealMethod && !member.is(Lazy)) {
         overrideError("must be declared lazy to override a lazy value")
-      } else if (other.is(Deferred) && member.is(Macro) && member.extendedOverriddenSymbols.forall(_.is(Deferred))) { // (1.9)
+      } 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)
         overrideError("cannot be used here - term macros cannot override abstract methods")
-      } else if (other.is(Macro) && !member.is(Macro)) { // (1.10)
+      } 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))) {

tests/neg/quotedMacroOverride.scala

@@ -0,0 +1,13 @@
+object Test {
+
+  abstract class A {
+    def f(): Unit
+    inline def g(): Unit = ()
+  }
+
+  class B extends A {
+    inline def f() = ~('())  // error: may not override
+    override def g() = ()    // error: may not override
+  }
+
+}