Expand macros in typer

This adds support for whitebox macros

Author: nicolasstucki

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

@@ -1313,10 +1313,6 @@ object desugar {
     val desugared = tree match {
       case SymbolLit(str) =>
         Literal(Constant(scala.Symbol(str)))
-      case Splice(expr) => // TODO move to typer and track level
-        Select(expr, nme.splice)
-      case TypSplice(expr) => // TODO move to typer and track level
-        Select(expr, tpnme.splice)
       case InterpolatedString(id, segments) =>
         val strs = segments map {
           case ts: Thicket => ts.trees.head

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

@@ -0,0 +1,25 @@
+package dotty.tools.dotc.core
+
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.util.Property
+
+import scala.collection.mutable
+
+object StagingContext {
+
+  /** A key to be used in a context property that tracks the quoteation level */
+  private val QuotationLevel = new Property.Key[Int]
+
+  /** All enclosing calls that are currently inlined, from innermost to outermost. */
+  def level(implicit ctx: Context): Int =
+    ctx.property(QuotationLevel).getOrElse(0)
+
+  /** Context with an incremented quotation level. */
+  def quoteContext(implicit ctx: Context): Context =
+    ctx.fresh.setProperty(QuotationLevel, level + 1)
+
+  /** Context with a decremented quotation level. */
+  def spliceContext(implicit ctx: Context): Context =
+    ctx.fresh.setProperty(QuotationLevel, level - 1)
+
+}

compiler/src/dotty/tools/dotc/core/quoted/PickledQuotes.scala

@@ -145,7 +145,7 @@ object PickledQuotes {
       case Block(stats, expr) =>
         seq(stats, rec(expr)).withSpan(fn.span)
       case _ =>
-        fn.select(nme.apply).appliedToArgs(argRefs())
+        fn.select(nme.apply).appliedToArgs(argRefs()).withSpan(fn.span)
     }
     Block(argVals, rec(fn))
   }

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

@@ -105,7 +105,7 @@ class ReifyQuotes extends MacroTransform {
   private class QuoteReifier(outer: QuoteReifier, capturers: mutable.HashMap[Symbol, Tree => Tree],
                              val embedded: Embedded, val owner: Symbol)(@constructorOnly ictx: Context) extends TreeMapWithStages(ictx) { self =>
 
-    import TreeMapWithStages._
+    import StagingContext._
 
     /** A nested reifier for a quote (if `isQuote = true`) or a splice (if not) */
     def nested(isQuote: Boolean)(implicit ctx: Context): QuoteReifier = {

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

@@ -8,7 +8,7 @@ import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.ast.Trees._
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Decorators._
-import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Flags.{Method => MethodFlag, _}
 import dotty.tools.dotc.core.NameKinds.FlatName
 import dotty.tools.dotc.core.Names.{Name, TermName}
 import dotty.tools.dotc.core.StdNames._
@@ -95,7 +95,7 @@ object Splicer {
     }
 
     protected def interpretQuote(tree: Tree)(implicit env: Env): Object =
-      new scala.quoted.Exprs.TastyTreeExpr(tree)
+      new scala.quoted.Exprs.TastyTreeExpr(Inlined(EmptyTree, Nil, tree).withSpan(tree.span))
 
     protected def interpretTypeQuote(tree: Tree)(implicit env: Env): Object =
       new scala.quoted.Types.TreeType(tree)
@@ -312,7 +312,13 @@ object Splicer {
 
     protected final def interpretTree(tree: Tree)(implicit env: Env): Result = tree match {
       case Apply(TypeApply(fn, _), quoted :: Nil) if fn.symbol == defn.QuotedExpr_apply =>
-        interpretQuote(quoted)
+        val quoted1 = quoted match {
+          case quoted: Ident if quoted.symbol.is(InlineProxy) && quoted.symbol.is(MethodFlag) => // inline proxy for by-name parameter
+            quoted.symbol.defTree.asInstanceOf[DefDef].rhs
+          case Inlined(EmptyTree, _, quoted) => quoted
+          case _ => quoted
+        }
+        interpretQuote(quoted1)
 
       case TypeApply(fn, quoted :: Nil) if fn.symbol == defn.QuotedType_apply =>
         interpretTypeQuote(quoted)
@@ -336,6 +342,8 @@ object Splicer {
           interpretStaticMethodCall(module, fn.symbol, args.map(arg => interpretTree(arg)))
         } else if (env.contains(fn.name)) {
           env(fn.name)
+        } else if (tree.symbol.is(InlineProxy)) {
+          interpretTree(tree.symbol.defTree.asInstanceOf[ValOrDefDef].rhs)
         } else {
           unexpectedTree(tree)
         }

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

@@ -9,6 +9,7 @@ import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.quoted._
 import dotty.tools.dotc.core.NameKinds._
+import dotty.tools.dotc.core.StagingContext._
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.tasty.TreePickler.Hole
@@ -89,16 +90,6 @@ object Staging {
     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))
@@ -122,25 +113,19 @@ object Staging {
         if (splice1.isType) splice1
         else addSpliceCast(splice1)
       }
-      else if (enclosingInlineds.nonEmpty) { // level 0 in an inlined call
-        val spliceCtx = ctx.outer // drop the last `inlineContext`
-        val pos: SourcePosition = spliceCtx.source.atSpan(enclosingInlineds.head.span)
-        val evaluatedSplice = Splicer.splice(splice.qualifier, pos, macroClassLoader)(spliceCtx)
-        if (ctx.reporter.hasErrors) splice else transform(evaluatedSplice.withSpan(splice.span))
-      }
-      else if (!ctx.owner.isInlineMethod) { // level 0 outside an inline method
-        ctx.error(i"splice outside quotes or inline method", splice.sourcePos)
-        splice
-      }
-      else if (Splicer.canBeSpliced(splice.qualifier)) { // level 0 inside an inline definition
-        transform(splice.qualifier)(spliceContext) // Just check PCP
-        splice
-      }
-      else { // level 0 inside an inline definition
-        ctx.error(
-          "Malformed macro call. The contents of the ~ must call a static method and arguments must be quoted or inline.",
-          splice.sourcePos)
-        splice
+      else {
+        assert(!enclosingInlineds.nonEmpty, "unexpanded macro")
+        assert(ctx.owner.isInlineMethod)
+        if (Splicer.canBeSpliced(splice.qualifier)) { // level 0 inside an inline definition
+          transform(splice.qualifier)(spliceContext) // Just check PCP
+          splice
+        }
+        else { // level 0 inside an inline definition
+          ctx.error(
+            "Malformed macro call. The contents of the $ must call a static method and arguments must be quoted or inline.",
+            splice.sourcePos)
+          splice
+        }
       }
     }
 

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

@@ -10,6 +10,7 @@ import dotty.tools.dotc.core.quoted._
 import dotty.tools.dotc.core.NameKinds._
 import dotty.tools.dotc.core.Types._
 import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.StagingContext._
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.tasty.TreePickler.Hole
@@ -129,21 +130,6 @@ object TreeMapWithStages {
   /** A key to be used in a context property that caches the `levelOf` mapping */
   private val LevelOfKey = new Property.Key[mutable.HashMap[Symbol, Int]]
 
-  /** A key to be used in a context property that tracks the quoteation level */
-  private val QuotationLevel = new Property.Key[Int]
-
-  /** All enclosing calls that are currently inlined, from innermost to outermost. */
-  def level(implicit ctx: Context): Int =
-    ctx.property(QuotationLevel).getOrElse(0)
-
-  /** Context with an incremented quotation level. */
-  def quoteContext(implicit ctx: Context): Context =
-    ctx.fresh.setProperty(QuotationLevel, level + 1)
-
-  /** Context with a decremented quotation level. */
-  def spliceContext(implicit ctx: Context): Context =
-    ctx.fresh.setProperty(QuotationLevel, level - 1)
-
   /** Initial context for a StagingTransformer transformation. */
   def freshStagingContext(implicit ctx: Context): Context =
     ctx.fresh.setProperty(LevelOfKey, new mutable.HashMap[Symbol, Int])

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

@@ -47,7 +47,9 @@ abstract class Lifter {
       var liftedType = expr.tpe.widen
       if (liftedFlags.is(Method)) liftedType = ExprType(liftedType)
       val lifted = ctx.newSymbol(ctx.owner, name, liftedFlags | Synthetic, liftedType, coord = spanCoord(expr.span))
-      defs += liftedDef(lifted, expr).withSpan(expr.span)
+      val ddef = liftedDef(lifted, expr).withSpan(expr.span)
+      lifted.defTree = ddef
+      defs += ddef
       ref(lifted.termRef).withSpan(expr.span.focus)
     }
 

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

@@ -2,7 +2,7 @@ package dotty.tools
 package dotc
 package typer
 
-import ast._
+import ast.{TreeInfo, tpd, _}
 import Trees._
 import core._
 import Flags._
@@ -25,6 +25,7 @@ import dotty.tools.dotc.util.{SimpleIdentityMap, SimpleIdentitySet, SourceFile,
 import collection.mutable
 import reporting.trace
 import util.Spans.Span
+import dotty.tools.dotc.transform.{Splicer, TreeMapWithStages}
 
 object Inliner {
   import tpd._
@@ -104,7 +105,7 @@ object Inliner {
     else if (enclosingInlineds.length < ctx.settings.XmaxInlines.value) {
       val body = bodyToInline(tree.symbol) // can typecheck the tree and thereby produce errors
       if (ctx.reporter.hasErrors) tree
-      else new Inliner(tree, body).inlined(pt)
+      else new Inliner(tree, body).inlined(pt, tree.sourcePos)
     }
     else
       errorTree(
@@ -381,7 +382,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
     }
 
   /** The Inlined node representing the inlined call */
-  def inlined(pt: Type): Tree = {
+  def inlined(pt: Type, sourcePos: SourcePosition): Tree = {
 
     if (callTypeArgs.length == 1)
       if (inlinedMethod == defn.Compiletime_constValue) {
@@ -487,7 +488,13 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
     trace(i"inlining $call", inlining, show = true) {
 
       // The normalized bindings collected in `bindingsBuf`
-      bindingsBuf.transform(reducer.normalizeBinding(_)(inlineCtx))
+      bindingsBuf.transform { binding =>
+        val transformedBinding = reducer.normalizeBinding(binding)(inlineCtx)
+        // Set trees to symbols allow macros to see the definition tree.
+        // This is used by `underlyingArgument`.
+        transformedBinding.symbol.defTree = transformedBinding
+        transformedBinding
+      }
 
       // Run a typing pass over the inlined tree. See InlineTyper for details.
       val expansion1 = inlineTyper.typed(expansion, pt)(inlineCtx)
@@ -949,11 +956,25 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
     override def typedSelect(tree: untpd.Select, pt: Type)(implicit ctx: Context): Tree = {
       assert(tree.hasType, tree)
       val qual1 = typed(tree.qualifier, selectionProto(tree.name, pt, this))
-      val res = untpd.cpy.Select(tree)(qual1, tree.name).withType(tree.typeOpt)
+      val res =
+        if (tree.symbol == defn.QuotedExpr_splice && StagingContext.level == 0) expandMacro(qual1, tree.span)
+        else untpd.cpy.Select(tree)(qual1, tree.name).withType(tree.typeOpt)
       ensureAccessible(res.tpe, tree.qualifier.isInstanceOf[untpd.Super], tree.sourcePos)
       res
     }
 
+    private def expandMacro(body: Tree, span: Span)(implicit ctx: Context) = {
+      assert(StagingContext.level == 0)
+      // TODO cache macro classloader
+      val urls = ctx.settings.classpath.value.split(java.io.File.pathSeparatorChar).map(cp => java.nio.file.Paths.get(cp).toUri.toURL)
+      val macroClassLoader = new java.net.URLClassLoader(urls, getClass.getClassLoader)
+
+      val inlinedFrom = enclosingInlineds.last
+      val evaluatedSplice = Splicer.splice(body, inlinedFrom.sourcePos, macroClassLoader)(ctx.withSource(inlinedFrom.source))
+      if (ctx.reporter.hasErrors) EmptyTree
+      else evaluatedSplice.withSpan(span)
+    }
+
     override def typedIf(tree: untpd.If, pt: Type)(implicit ctx: Context): Tree =
       typed(tree.cond, defn.BooleanType) match {
         case cond1 @ ConstantValue(b: Boolean) =>

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

@@ -37,6 +37,7 @@ import config.Printers.{gadts, typr}
 import rewrites.Rewrites.patch
 import NavigateAST._
 import dotty.tools.dotc.transform.{PCPCheckAndHeal, Staging, TreeMapWithStages}
+import dotty.tools.dotc.core.StagingContext._
 import transform.SymUtils._
 import transform.TypeUtils._
 import reporting.trace
@@ -1567,7 +1568,7 @@ class Typer extends Namer
 
         if (isMacro) {
           sym.setFlag(Macro)
-          if (TreeMapWithStages.level == 0)
+          if (level == 0)
           rhs1 match {
             case InlineSplice(_) =>
               new PCPCheckAndHeal(freshStagingContext).transform(rhs1) // Ignore output, only check PCP
@@ -1960,14 +1961,33 @@ class Typer extends Namer
     }
   }
 
-  /** Translate `'(expr)`/`'{ expr* }` into `scala.quoted.Expr.apply(expr)` and `'[T]` into `scala.quoted.Type.apply[T]`
+  /** Translate '{ t }` into `scala.quoted.Expr.apply(t)` 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.t.isType)
-      typedTypeApply(untpd.TypeApply(untpd.ref(defn.QuotedType_applyR), List(tree.t)), pt)(TreeMapWithStages.quoteContext).withSpan(tree.span)
-    else
-      typedApply(untpd.Apply(untpd.ref(defn.QuotedExpr_applyR), tree.t), pt)(TreeMapWithStages.quoteContext).withSpan(tree.span)
+    val tree1 =
+      if (tree.t.isType)
+        typedTypeApply(untpd.TypeApply(untpd.ref(defn.QuotedType_applyR), List(tree.t)), pt)(quoteContext)
+      else
+        typedApply(untpd.Apply(untpd.ref(defn.QuotedExpr_applyR), tree.t), pt)(quoteContext)
+    tree1.withSpan(tree.span)
+  }
+
+  /** Translate `${ t: Expr[T] }` into expresiion `t.splice` while tracking the quotation level in the context */
+  def typedSplice(tree: untpd.Splice, pt: Type)(implicit ctx: Context): Tree = track("typedSplice") {
+    checkSpliceOutsideQuote(tree)
+    typedSelect(untpd.Select(tree.expr, nme.splice), pt)(spliceContext).withSpan(tree.span)
+  }
+
+  /** Translate ${ t: Type[T] }` into type `t.splice` while tracking the quotation level in the context */
+  def typedTypSplice(tree: untpd.TypSplice, pt: Type)(implicit ctx: Context): Tree = track("typedTypSplice") {
+    checkSpliceOutsideQuote(tree)
+    typedSelect(untpd.Select(tree.expr, tpnme.splice), pt)(spliceContext).withSpan(tree.span)
+  }
+
+  private def checkSpliceOutsideQuote(tree: untpd.Tree)(implicit ctx: Context): Unit = {
+    if (level == 0 && !ctx.owner.isInlineMethod)
+      ctx.error("splice outside quotes or inline method", tree.sourcePos)
   }
 
   /** Retrieve symbol attached to given tree */
@@ -2061,6 +2081,8 @@ class Typer extends Namer
           case tree @ untpd.PostfixOp(qual, Ident(nme.WILDCARD)) => typedAsFunction(tree, pt)
           case untpd.EmptyTree => tpd.EmptyTree
           case tree: untpd.Quote => typedQuote(tree, pt)
+          case tree: untpd.Splice => typedSplice(tree, pt)
+          case tree: untpd.TypSplice => typedTypSplice(tree, pt)
           case _ => typedUnadapted(desugar(tree), pt, locked)
         }