Change macro labelling

 - Mark a method with a toplevel splice as a macro already when
   we register the inline info. This is needed so that such methods
   are recognized as erased the first time someone wants to inline them.
 - Improve error message for splice outside quote.

Author: odersky

compiler/src/dotty/tools/dotc/reporting/diagnostic/ErrorMessageID.java

@@ -131,6 +131,7 @@ public enum ErrorMessageID {
     MatchCaseOnlyNullWarningID,
     ImportRenamedTwiceID,
     TypeTestAlwaysSucceedsID,
+    SpliceOutsideQuotesID,
     ;
 
     public int errorNumber() {

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -2105,4 +2105,12 @@ object messages {
     }
     val explanation = ""
   }
+
+  case class SpliceOutsideQuotes() extends Message(SpliceOutsideQuotesID) {
+    val kind = "Syntax"
+    val msg = "splice outside quotes"
+    val explanation =
+      """A splice may only appear inside quotes '{ ... },
+        |or else it must be the whole right hand side of a transparent method.""".stripMargin
+  }
 }

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

@@ -156,23 +156,10 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
         }
     }
 
-    /** 1. If we are in a transparent method but not in a nested quote, mark the transparent method
-     *  as a macro.
-     *
-     *  2. If selection is a quote or splice node, record that fact in the current compilation unit.
+    /** 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.isTransparentMethod) c.owner.setFlag(Macro | Erased)
-        else if (!c.outer.owner.is(Package)) markAsMacro(c.outer)
-
-      if (sym.isSplice || sym.isQuote) {
-        markAsMacro(ctx)
-        ctx.compilationUnit.containsQuotesOrSplices = true
-      }
-    }
+    private def recordMeta(sym: Symbol)(implicit ctx: Context): Unit =
+      if (sym.isSplice || sym.isQuote) ctx.compilationUnit.containsQuotesOrSplices = true
 
     private object dropInlines extends TreeMap {
       override def transform(tree: Tree)(implicit ctx: Context): Tree = tree match {
@@ -184,13 +171,13 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
     override def transform(tree: Tree)(implicit ctx: Context): Tree =
       try tree match {
         case tree: Ident if !tree.isType =>
-          handleMeta(tree.symbol)
+          recordMeta(tree.symbol)
           tree.tpe match {
             case tpe: ThisType => This(tpe.cls).withPos(tree.pos)
             case _ => tree
           }
         case tree @ Select(qual, name) =>
-          handleMeta(tree.symbol)
+          recordMeta(tree.symbol)
           if (name.isTypeName) {
             Checking.checkRealizable(qual.tpe, qual.pos.focus)
             super.transform(tree)(ctx.addMode(Mode.Type))

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

@@ -12,7 +12,7 @@ import SymUtils._
 import NameKinds._
 import dotty.tools.dotc.ast.tpd.Tree
 import typer.Implicits.SearchFailureType
-
+import reporting.diagnostic.messages._
 import scala.collection.mutable
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.quoted._
@@ -230,7 +230,7 @@ class ReifyQuotes extends MacroTransformWithImplicits {
 
     /** Issue a "splice outside quote" error unless we are in the body of a transparent method */
     def spliceOutsideQuotes(pos: Position)(implicit ctx: Context): Unit =
-      ctx.error(i"splice outside quotes", pos)
+      ctx.error(SpliceOutsideQuotes(), pos)
 
     /** Try to heal phase-inconsistent reference to type `T` using a local type definition.
      *  @return None      if successful

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

@@ -20,6 +20,7 @@ import ProtoTypes.selectionProto
 import SymDenotations.SymDenotation
 import Annotations._
 import transform.{ExplicitOuter, AccessProxies}
+import transform.SymUtils._
 import Inferencing.fullyDefinedType
 import config.Printers.inlining
 import ErrorReporting.errorTree
@@ -250,6 +251,15 @@ object PrepareTransparent {
           inlined.updateAnnotation(LazyBodyAnnotation { _ =>
             implicit val ctx = inlineCtx
             val rawBody = treeExpr(ctx)
+
+            def markAsMacro(body: Tree): Unit = body match {
+              case _: Select if body.symbol.isSplice => inlined.setFlag(Erased | Macro)
+              case Block(Nil, expr) => markAsMacro(expr)
+              case Block(expr :: Nil, Literal(Constant(()))) => markAsMacro(expr)
+              case _ =>
+            }
+            markAsMacro(rawBody)
+
             val typedBody =
               if (ctx.reporter.hasErrors) rawBody
               else ctx.compilationUnit.inlineAccessors.makeInlineable(rawBody)

tests/neg/quote-macro-splice.scala

@@ -2,23 +2,23 @@ import scala.quoted._
 
 object Test {
 
-  transparent def foo1: Int = { // error
+  transparent def foo1: Int = {
     println()
-    ~impl(1.toExpr)
+    ~impl(1.toExpr) // error: splice outside quotes
   }
 
-  transparent def foo2: Int = { // error
-    ~impl(1.toExpr)
-    ~impl(2.toExpr)
+  transparent def foo2: Int = {
+    ~impl(1.toExpr)  // error: splice outside quotes
+    ~impl(2.toExpr)  // error: splice outside quotes
   }
 
-  transparent def foo3: Int = { // error
+  transparent def foo3: Int = {
     val a = 1
-    ~impl('(a))
+    ~impl('(a)) // error: splice outside quotes
   }
 
-  transparent def foo4: Int = { // error
-    ~impl('(1))
+  transparent def foo4: Int = {
+    ~impl('(1))  // error: splice outside quotes
     1
   }