Move Staging check into typer

Author: nicolasstucki

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -1350,11 +1350,6 @@ object desugar {
     val desugared = tree match {
       case SymbolLit(str) =>
         Literal(Constant(scala.Symbol(str)))
-      case Quote(expr) =>
-        if (expr.isType)
-          TypeApply(ref(defn.QuotedType_applyR), List(expr))
-        else
-          Apply(ref(defn.QuotedExpr_applyR), expr)
       case InterpolatedString(id, segments) =>
         val strs = segments map {
           case ts: Thicket => ts.trees.head

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

@@ -37,16 +37,6 @@ class Staging extends MacroTransform {
   import tpd._
   import Staging._
 
-  /** Classloader used for loading macros */
-  private[this] var myMacroClassLoader: java.lang.ClassLoader = _
-  private def macroClassLoader(implicit ctx: Context): ClassLoader = {
-    if (myMacroClassLoader == null) {
-      val urls = ctx.settings.classpath.value.split(java.io.File.pathSeparatorChar).map(cp => java.nio.file.Paths.get(cp).toUri.toURL)
-      myMacroClassLoader = new java.net.URLClassLoader(urls, getClass.getClassLoader)
-    }
-    myMacroClassLoader
-  }
-
   override def phaseName: String = Staging.name
 
   override def allowsImplicitSearch: Boolean = true
@@ -88,39 +78,30 @@ class Staging extends MacroTransform {
       new PCPCheckAndHeal(ctx).transform(tree)
   }
 
-  private class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(ictx) {
 
-    override def transform(tree: Tree)(implicit ctx: Context): Tree = {
-      reporting.trace(i"PCPTransformer.transform $tree at $level", show = true) {
-        tree match {
-          case tree: DefDef if tree.symbol.is(Macro) =>
-            if (level > 0) {
-              super.transform(tree) // Ignore output, only check PCP
-              EmptyTree // Already inlined
-            }
-            else if (enclosingInlineds.nonEmpty) {
-              EmptyTree // Already checked at definition site and already inlined
-            }
-            else tree.rhs match {
-              case InlineSplice(_) =>
-                super.transform(tree) // Ignore output, only check PCP
-                tree
-              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, tree.rhs.sourcePos)
-                tree
-            }
-          case _ =>
-            checkLevel(super.transform(tree))
-        }
+}
+
+object Staging {
+  val name: String = "staging"
+}
+
+  class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(ictx) {
+    import tpd._
+    import PCPCheckAndHeal._
+
+    /** Classloader used for loading macros */
+    private[this] var myMacroClassLoader: java.lang.ClassLoader = _
+    private def macroClassLoader(implicit ctx: Context): ClassLoader = {
+      if (myMacroClassLoader == null) {
+        val urls = ctx.settings.classpath.value.split(java.io.File.pathSeparatorChar).map(cp => java.nio.file.Paths.get(cp).toUri.toURL)
+        myMacroClassLoader = new java.net.URLClassLoader(urls, getClass.getClassLoader)
       }
+      myMacroClassLoader
+    }
+
+    override def transform(tree: Tree)(implicit ctx: Context): Tree = tree match {
+      case tree: DefDef if tree.symbol.is(Inline) && level > 0 => EmptyTree
+      case _ => checkLevel(super.transform(tree))
     }
 
     /** Transform quoted trees while maintaining phase correctness */
@@ -307,10 +288,16 @@ class Staging extends MacroTransform {
       }
     }
 
+
+  }
+
+  object PCPCheckAndHeal {
+    import tpd._
+
     /** InlineSplice is used to detect cases where the expansion
      *  consists of a (possibly multiple & nested) block or a sole expression.
      */
-    private object InlineSplice {
+    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)
@@ -319,11 +306,4 @@ class Staging extends MacroTransform {
         case _ => None
       }
     }
-
   }
-
-}
-
-object Staging {
-  val name: String = "staging"
-}

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

@@ -815,7 +815,6 @@ class Namer { typer: Typer =>
       case original: untpd.DefDef if sym.isInlineMethod =>
         PrepareInlineable.registerInlineInfo(
             sym,
-            original.rhs,
             implicit ctx => typedAheadExpr(original).asInstanceOf[tpd.DefDef].rhs
           )(localContext(sym))
       case _ =>

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

@@ -219,7 +219,7 @@ object PrepareInlineable {
    *                     to have the inline method as owner.
    */
   def registerInlineInfo(
-      inlined: Symbol, originalBody: untpd.Tree, treeExpr: Context => Tree)(implicit ctx: Context): Unit = {
+      inlined: Symbol, treeExpr: Context => Tree)(implicit ctx: Context): Unit = {
     inlined.unforcedAnnotation(defn.BodyAnnot) match {
       case Some(ann: ConcreteBodyAnnotation) =>
       case Some(ann: LazyBodyAnnotation) if ann.isEvaluated =>

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

@@ -27,7 +27,7 @@ import EtaExpansion.etaExpand
 import util.Spans._
 import util.common._
 import util.Property
-import Applications.{ExtMethodApply, wrapDefs, productSelectorTypes}
+import Applications.{ExtMethodApply, productSelectorTypes, wrapDefs}
 
 import collection.mutable
 import annotation.tailrec
@@ -36,6 +36,7 @@ import util.Stats.{record, track}
 import config.Printers.{gadts, typr}
 import rewrites.Rewrites.patch
 import NavigateAST._
+import dotty.tools.dotc.transform.{PCPCheckAndHeal, Staging, TreeMapWithStages}
 import transform.SymUtils._
 import transform.TypeUtils._
 import reporting.trace
@@ -1548,7 +1549,39 @@ class Typer extends Namer
     if (sym.isInlineMethod) rhsCtx = rhsCtx.addMode(Mode.InlineableBody)
     val rhs1 = typedExpr(ddef.rhs, tpt1.tpe)(rhsCtx)
 
-    if (sym.isInlineMethod) PrepareInlineable.registerInlineInfo(sym, ddef.rhs, _ => rhs1)
+    if (sym.isInlineMethod) {
+      if (ctx.phase.isTyper) {
+        import PCPCheckAndHeal.InlineSplice
+        import TreeMapWithStages._
+        var isMacro = false
+        new TreeMapWithStages(freshStagingContext){
+          override protected def splice(splice: tpd.Select)(implicit ctx: Context): tpd.Tree = {
+            isMacro = true
+            splice
+          }
+        }.transform(rhs1)
+
+        if (isMacro) {
+          sym.setFlag(Macro)
+          if (TreeMapWithStages.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.registerInlineInfo(sym, _ => rhs1)
+    }
 
     if (sym.isConstructor && !sym.isPrimaryConstructor)
       for (param <- tparams1 ::: vparamss1.flatten)
@@ -1923,6 +1956,16 @@ class Typer extends Namer
     }
   }
 
+  /** Translate `'(expr)`/`'{ expr* }` into `scala.quoted.Expr.apply(expr)` and `'[T]` into `scala.quoted.Type.apply[T]`
+   *  while tracking the quotation level in the context.
+   */
+  def typedQuote(tree: untpd.Quote, pt: Type)(implicit ctx: Context): Tree = track("typedQuote") {
+    if (tree.expr.isType)
+      typedTypeApply(untpd.TypeApply(untpd.ref(defn.QuotedType_applyR), List(tree.expr)), pt)(TreeMapWithStages.quoteContext).withSpan(tree.span)
+    else
+      typedApply(untpd.Apply(untpd.ref(defn.QuotedExpr_applyR), tree.expr), pt)(TreeMapWithStages.quoteContext).withSpan(tree.span)
+  }
+
   /** Retrieve symbol attached to given tree */
   protected def retrieveSym(tree: untpd.Tree)(implicit ctx: Context): Symbol = tree.removeAttachment(SymOfTree) match {
     case Some(sym) =>
@@ -2015,6 +2058,7 @@ class Typer extends Namer
           case tree: untpd.InfixOp if ctx.mode.isExpr => typedInfixOp(tree, pt)
           case tree @ untpd.PostfixOp(qual, Ident(nme.WILDCARD)) => typedAsFunction(tree, pt)
           case untpd.EmptyTree => tpd.EmptyTree
+          case tree: untpd.Quote => typedQuote(tree, pt)
           case _ => typedUnadapted(desugar(tree), pt, locked)
         }
 

tests/neg/quote-this-b.scala

@@ -0,0 +1,10 @@
+import scala.quoted._
+
+class Foo {
+  inline def k(): Unit = ~Foo.impl[Any](this) // error
+  inline def l(that: Foo): Unit = ~Foo.impl[Any](that) // error
+}
+
+object Foo {
+  def impl[T](x: Any): Expr[Unit] = '()
+}

tests/neg/quote-this.scala

@@ -19,9 +19,6 @@ class Foo {
     '(that) // error
   })
 
-  inline def k(): Unit = ~Foo.impl[Any](this) // error
-  inline def l(that: Foo): Unit = ~Foo.impl[Any](that) // error
-
 }
 
 object Foo {

tests/pos/quote-1.scala

@@ -11,6 +11,6 @@ object Test {
    f('{ true })('[Boolean])
 
   def g(es: Expr[String], t: Type[String]) =
-    f('{ (~es + "!") :: Nil })('[List[~t]])
+    f('{ (~es + "!") :: Nil })('[List[t.unary_~]])
 }