Cleanup macro PCP checks

Author: nicolasstucki

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

@@ -88,7 +88,6 @@ object Staging {
 
   class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(ictx) {
     import tpd._
-    import PCPCheckAndHeal._
 
     override def transform(tree: Tree)(implicit ctx: Context): Tree = tree match {
       case tree: DefDef if tree.symbol.is(Inline) && level > 0 => EmptyTree
@@ -273,22 +272,4 @@ object Staging {
       }
     }
 
-
-  }
-
-  object PCPCheckAndHeal {
-    import tpd._
-
-    /** InlineSplice is used to detect cases where the expansion
-     *  consists of a (possibly multiple & nested) block or a sole expression.
-     */
-    object InlineSplice {
-      def unapply(tree: Tree)(implicit ctx: Context): Option[Tree] = tree match {
-        case Spliced(code) if Splicer.canBeSpliced(code) => Some(code)
-        case Block(List(stat), Literal(Constant(()))) => unapply(stat)
-        case Block(Nil, expr) => unapply(expr)
-        case Typed(expr, _) => unapply(expr)
-        case _ => None
-      }
-    }
   }

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

@@ -2,7 +2,7 @@ package dotty.tools
 package dotc
 package typer
 
-import dotty.tools.dotc.ast.{Trees, untpd, tpd}
+import dotty.tools.dotc.ast.{Trees, tpd, untpd}
 import Trees._
 import core._
 import Flags._
@@ -15,9 +15,11 @@ import Contexts.Context
 import Names.Name
 import NameKinds.{InlineAccessorName, UniqueInlineName}
 import Annotations._
-import transform.AccessProxies
+import transform.{AccessProxies, PCPCheckAndHeal, Splicer, TreeMapWithStages}
 import config.Printers.inlining
-import util.Property
+import util.{Property, SourcePosition}
+import dotty.tools.dotc.core.StagingContext._
+import dotty.tools.dotc.transform.TreeMapWithStages._
 
 object PrepareInlineable {
   import tpd._
@@ -249,4 +251,52 @@ object PrepareInlineable {
         em"inline unapply method can be rewritten only if its right hand side is a tuple (e1, ..., eN)",
         body.sourcePos)
   }
+
+  def checkInlineMacro(sym: Symbol, rhs: Tree, pos: SourcePosition)(implicit ctx: Context) = {
+    if (ctx.phase.isTyper) {
+
+      /** InlineSplice is used to detect cases where the expansion
+       *  consists of a (possibly multiple & nested) block or a sole expression.
+       */
+      object InlineSplice {
+        def unapply(tree: Tree)(implicit ctx: Context): Option[Tree] = tree match {
+          case Spliced(code) if Splicer.canBeSpliced(code) => Some(code)
+          case Block(List(stat), Literal(Constants.Constant(()))) => unapply(stat)
+          case Block(Nil, expr) => unapply(expr)
+          case Typed(expr, _) => unapply(expr)
+          case _ => None
+        }
+      }
+
+      var isMacro = false
+      new TreeMapWithStages(freshStagingContext) {
+        override protected def transformSplice(splice: tpd.Select)(implicit ctx: Context): tpd.Tree = {
+          isMacro = true
+          splice
+        }
+        override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree =
+          if (isMacro) tree else super.transform(tree)
+      }.transform(rhs)
+
+      if (isMacro) {
+        sym.setFlag(Macro)
+        if (level == 0)
+          rhs match {
+            case InlineSplice(_) =>
+              new PCPCheckAndHeal(freshStagingContext).transform(rhs) // Ignore output, only check PCP
+            case _ =>
+              ctx.error(
+                """Malformed macro.
+                  |
+                  |Expected the ~ to be at the top of the RHS:
+                  |  inline def foo(inline x: X, ..., y: Y): Int = ~impl(x, ... '(y))
+                  |
+                  | * The contents of the splice must call a static method
+                  | * All arguments must be quoted or inline
+                """.stripMargin, pos)
+          }
+      }
+    }
+  }
+
 }

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

@@ -1556,36 +1556,7 @@ class Typer extends Namer
     val rhs1 = typedExpr(ddef.rhs, tpt1.tpe.widenExpr)(rhsCtx)
 
     if (sym.isInlineMethod) {
-      if (ctx.phase.isTyper) {
-        import PCPCheckAndHeal.InlineSplice
-        import TreeMapWithStages._
-        var isMacro = false
-        new TreeMapWithStages(freshStagingContext) {
-          override protected def transformSplice(splice: tpd.Select)(implicit ctx: Context): tpd.Tree = {
-            isMacro = true
-            splice
-          }
-        }.transform(rhs1)
-
-        if (isMacro) {
-          sym.setFlag(Macro)
-          if (level == 0)
-          rhs1 match {
-            case InlineSplice(_) =>
-              new PCPCheckAndHeal(freshStagingContext).transform(rhs1) // Ignore output, only check PCP
-            case _ =>
-              ctx.error(
-                """Malformed macro.
-                  |
-                  |Expected the ~ to be at the top of the RHS:
-                  |  inline def foo(inline x: X, ..., y: Y): Int = ~impl(x, ... '(y))
-                  |
-                  | * The contents of the splice must call a static method
-                  | * All arguments must be quoted or inline
-                """.stripMargin, ddef.sourcePos)
-          }
-        }
-      }
+      PrepareInlineable.checkInlineMacro(sym, rhs1, ddef.sourcePos)
       PrepareInlineable.registerInlineInfo(sym, _ => rhs1)
     }
 

tests/neg/splice-in-top-level-splice-1.scala

@@ -1,7 +1,7 @@
 import scala.quoted._
 
 object Foo {
-  inline def foo(): Int = ${bar($x)} // error
+  inline def foo(): Int = ${bar(${x})} // error
   def x: Expr[Int] = '{1}
   def bar(i: Int): Expr[Int] = i.toExpr
 }