Mark inline methods containing splices as macros

If an inline method contains a toplevel splice, mark it s a macro.
Furthermore, allow for serialization of the Macro flag in Tasty.

Author: odersky

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

@@ -414,7 +414,7 @@ object Flags {
   /** A Scala 2.12 or higher trait */
   final val Scala_2_12_Trait = typeFlag(58, "<scala_2_12_trait>")
 
-  /** A macro (Scala 2.x only) */
+  /** A macro */
   final val Macro = commonFlag(59, "<macro>")
 
   /** A method that is known to have inherited default parameters */

compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala

@@ -181,7 +181,8 @@ Standard-Section: "ASTs" TopLevelStat*
                   IMPLICIT
                   LAZY
                   OVERRIDE
-                  INLINE                              // macro
+                  INLINE                              // inline method
+                  MACRO                               // inline method containing toplevel splices
                   STATIC                              // mapped to static Java member
                   OBJECT                              // an object or its class
                   TRAIT                               // a trait
@@ -226,7 +227,7 @@ object TastyFormat {
 
   final val header = Array(0x5C, 0xA1, 0xAB, 0x1F)
   val MajorVersion = 2
-  val MinorVersion = 0
+  val MinorVersion = 1
 
   /** Tags used to serialize names */
   class NameTags {
@@ -297,6 +298,7 @@ object TastyFormat {
   final val SCALA2X = 29
   final val DEFAULTparameterized = 30
   final val STABLE = 31
+  final val MACRO = 32
 
   // Cat. 2:    tag Nat
 
@@ -419,6 +421,7 @@ object TastyFormat {
        | LAZY
        | OVERRIDE
        | INLINE
+       | MACRO
        | STATIC
        | OBJECT
        | TRAIT
@@ -472,6 +475,7 @@ object TastyFormat {
     case LAZY => "LAZY"
     case OVERRIDE => "OVERRIDE"
     case INLINE => "INLINE"
+    case MACRO => "MACRO"
     case STATIC => "STATIC"
     case OBJECT => "OBJECT"
     case TRAIT => "TRAIT"

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -587,6 +587,7 @@ class TreePickler(pickler: TastyPickler) {
     if (flags is Case) writeByte(CASE)
     if (flags is Override) writeByte(OVERRIDE)
     if (flags is Inline) writeByte(INLINE)
+    if (flags is Macro) writeByte(MACRO)
     if (flags is JavaStatic) writeByte(STATIC)
     if (flags is Module) writeByte(OBJECT)
     if (flags is Local) writeByte(LOCAL)

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -524,6 +524,7 @@ class TreeUnpickler(reader: TastyReader,
           case LAZY => addFlag(Lazy)
           case OVERRIDE => addFlag(Override)
           case INLINE => addFlag(Inline)
+          case MACRO => addFlag(Macro)
           case STATIC => addFlag(JavaStatic)
           case OBJECT => addFlag(Module)
           case TRAIT => addFlag(Trait)

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

@@ -11,11 +11,11 @@ import StdNames._
 import ast.untpd
 import tasty.TreePickler.Hole
 import MegaPhase.MiniPhase
+import SymUtils._
 import NameKinds.OuterSelectName
 import scala.collection.mutable
 
 // TODO
-//   implement hole substitution directly
 //   check that inline methods override nothing
 //   drop inline methods
 //   adapt to Expr/Type when passing arguments to splices
@@ -175,10 +175,6 @@ class ReifyQuotes extends MacroTransform {
       case _ =>
     }
 
-    /** Is symbol a splice operation? */
-    def isSplice(sym: Symbol)(implicit ctx: Context) =
-      sym == defn.QuotedExpr_~ || sym == defn.QuotedType_~
-
     /** Are we in the body of an inline method? */
     def inInline(implicit ctx: Context) = ctx.owner.ownersIterator.exists(_.isInlineMethod)
 
@@ -213,7 +209,7 @@ class ReifyQuotes extends MacroTransform {
     def checkType(pos: Position)(implicit ctx: Context): TypeAccumulator[Unit] = new TypeAccumulator[Unit] {
       def apply(acc: Unit, tp: Type): Unit = reporting.trace(i"check type level $tp at $level") {
         tp match {
-          case tp: NamedType if isSplice(tp.symbol) =>
+          case tp: NamedType if tp.symbol.isSplice =>
             if (inQuote) outer.checkType(pos).foldOver(acc, tp)
             else {
               spliceOutsideQuotes(pos)
@@ -328,13 +324,13 @@ class ReifyQuotes extends MacroTransform {
             quotation(arg, tree)
           case TypeApply(fn, arg :: Nil) if fn.symbol == defn.typeQuoteMethod =>
              quotation(arg, tree)
-          case Select(body, _) if isSplice(tree.symbol) =>
+          case Select(body, _) if tree.symbol.isSplice =>
             splice(body, tree)
           case Block(stats, _) =>
             val last = enteredSyms
             stats.foreach(markDef)
             mapOverTree(last)
-          case Inlined(call, bindings, expansion @ Select(body, name)) if isSplice(expansion.symbol) =>
+          case Inlined(call, bindings, expansion @ Select(body, name)) if expansion.symbol.isSplice =>
             // To maintain phase consistency, convert inlined expressions of the form
             // `{ bindings; ~expansion }` to `~{ bindings; expansion }`
             cpy.Select(expansion)(cpy.Inlined(tree)(call, bindings, body), name)

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

@@ -175,4 +175,8 @@ class SymUtils(val self: Symbol) extends AnyVal {
     else if (owner.is(Package)) false
     else owner.isLocal
   }
+
+  /** Is symbol a splice operation? */
+  def isSplice(implicit ctx: Context): Boolean =
+    self == defn.QuotedExpr_~ || self == defn.QuotedType_~
 }

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

@@ -393,11 +393,24 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     checkValue(assignType(cpy.Select(tree)(qual, tree.name), qual), pt)
 
   def typedSelect(tree: untpd.Select, pt: Type)(implicit ctx: Context): Tree = track("typedSelect") {
+
+    /** If we are an an inline method but not in a nested quote, mark the inline method
+     *  as a macro.
+     */
+    def markAsMacro(c: Context): Unit =
+      if (!c.tree.isInstanceOf[untpd.Quote])
+        if (c.owner eq c.outer.owner) markAsMacro(c.outer)
+        else if (c.owner.isInlineMethod) c.owner.setFlag(Macro)
+        else if (!c.outer.owner.is(Package)) markAsMacro(c.outer)
+
     def typeSelectOnTerm(implicit ctx: Context): Tree = {
       val qual1 = typedExpr(tree.qualifier, selectionProto(tree.name, pt, this))
       if (tree.name.isTypeName) checkStable(qual1.tpe, qual1.pos)
       val select = typedSelect(tree, pt, qual1)
-      if (select.tpe ne TryDynamicCallType) select
+      if (select.tpe ne TryDynamicCallType) {
+        if (select.symbol.isSplice) markAsMacro(ctx)
+        select
+      }
       else if (pt.isInstanceOf[PolyProto] || pt.isInstanceOf[FunProto] || pt == AssignProto) select
       else typedDynamicSelect(tree, Nil, pt)
     }
@@ -1081,10 +1094,13 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       case AppliedType(_, argType :: Nil) => argType
       case _ => WildcardType
     }
-    if (isType)
-      ref(defn.typeQuoteMethod).appliedToTypeTrees(typedType(body, proto1) :: Nil)
+    val nestedCtx = ctx.fresh.setTree(tree)
+    if (isType) {
+      val body1 = typedType(body, proto1)(nestedCtx)
+      ref(defn.typeQuoteMethod).appliedToTypeTrees(body1 :: Nil)
+    }
     else {
-      val body1 = typed(body, proto1)
+      val body1 = typed(body, proto1)(nestedCtx)
       ref(defn.quoteMethod).appliedToType(body1.tpe.widen).appliedTo(body1)
     }
   }