Set Macro flag and containsQuotesOrSplices in PostTyper

It's easier to handle this in PostTyper since then we do
not need to distinguish between inlined and normal code.

Also, need to record quotes as well as splices since ReifyQuotes
should also do macro expansion.

Also, add a missing recursive call to `transform` in ReifyQuotes.

Author: odersky

compiler/src/dotty/tools/dotc/CompilationUnit.scala

@@ -25,7 +25,7 @@ class CompilationUnit(val source: SourceFile) {
   /** Will be reset to `true` if `untpdTree` contains `Quote` trees. The information
    *  is used in phase ReifyQuotes in order to avoid traversing a quote-less tree.
    */
-  var containsQuotes: Boolean = false
+  var containsQuotesOrSplices: Boolean = false
 }
 
 object CompilationUnit {

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

@@ -159,6 +159,24 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
         }
     }
 
+    /** 1. If we are an an inline method but not in a nested quote, mark the inline method
+     *  as a macro.
+     *
+     *  2. If selection is a quote or splice node, record that fact in the current compilation unit.
+     */
+    private def handleMeta(sym: Symbol)(implicit ctx: Context): Unit = {
+
+      def markAsMacro(c: Context): Unit =
+        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)
+
+      if (sym.isSplice || sym.isQuote) {
+        markAsMacro(ctx)
+        ctx.compilationUnit.containsQuotesOrSplices = true
+      }
+    }
+
     override def transform(tree: Tree)(implicit ctx: Context): Tree =
       try tree match {
         case tree: Ident if !tree.isType =>
@@ -167,6 +185,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
             case _ => tree
           }
         case tree @ Select(qual, name) =>
+          handleMeta(tree.symbol)
           if (name.isTypeName) {
             Checking.checkRealizable(qual.tpe, qual.pos.focus)
             super.transform(tree)

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

@@ -24,7 +24,7 @@ class ReifyQuotes extends MacroTransform {
   override def phaseName: String = "reifyQuotes"
 
   override def run(implicit ctx: Context): Unit =
-    if (ctx.compilationUnit.containsQuotes) super.run
+    if (ctx.compilationUnit.containsQuotesOrSplices) super.run
 
   protected def newTransformer(implicit ctx: Context): Transformer =
     new Reifier(inQuote = false, null, 0, new LevelInfo)
@@ -336,7 +336,7 @@ class ReifyQuotes extends MacroTransform {
           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)
+            transform(cpy.Select(expansion)(cpy.Inlined(tree)(call, bindings, body), name))
           case _: Import =>
             tree
           case tree: DefDef if tree.symbol.is(Macro) && level == 0 =>

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

@@ -176,6 +176,10 @@ class SymUtils(val self: Symbol) extends AnyVal {
     else owner.isLocal
   }
 
+  /** Is symbol a quote operation? */
+  def isQuote(implicit ctx: Context): Boolean =
+    self == defn.quoteMethod || self == defn.typeQuoteMethod
+
   /** 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

@@ -394,23 +394,11 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
 
   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) {
-        if (select.symbol.isSplice) markAsMacro(ctx)
-        select
-      }
+      if (select.tpe ne TryDynamicCallType) select
       else if (pt.isInstanceOf[PolyProto] || pt.isInstanceOf[FunProto] || pt == AssignProto) select
       else typedDynamicSelect(tree, Nil, pt)
     }
@@ -1086,7 +1074,6 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   }
 
   def typedQuote(tree: untpd.Quote, pt: Type)(implicit ctx: Context): Tree = track("typedQuote") {
-    ctx.compilationUnit.containsQuotes = true
     val untpd.Quote(body) = tree
     val isType = body.isType
     val resultClass = if (isType) defn.QuotedTypeClass else defn.QuotedExprClass