WIP

Author: nicolasstucki

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

@@ -10,7 +10,7 @@ import dotty.tools.dotc.transform.SymUtils._
 object Quoted {
 
  /** Extracts the content of a quoted tree.
- * The result can be the contents of a term ot type quote, which
+ * The result can be the contents of a term or type quote, which
  * will return a term or type tree respectively.
  */
  def unapply(tree: tpd.Tree)(implicit ctx: Context): Option[tpd.Tree] = tree match {

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

@@ -0,0 +1,19 @@
+package dotty.tools.dotc.core.quoted
+
+import dotty.tools.dotc.ast.Trees._
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Types.Type
+import dotty.tools.dotc.transform.SymUtils._
+
+/** Extractors for splices */
+object Spliced {
+
+ /** Extracts the content of a spliced tree.
+ * The result can be the contents of a term or type splice, which
+ * will return a term or type tree respectively.
+ */
+ def unapply(tree: tpd.Select)(implicit ctx: Context): Option[tpd.Tree] =
+ if (tree.symbol.isSplice) Some(tree.qualifier) else None
+
+}

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

@@ -0,0 +1,137 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Decorators._
+import Flags._
+import Types._
+import Contexts._
+import Symbols._
+import Constants._
+import ast.Trees._
+import ast.{TreeTypeMap, tpd, untpd}
+import util.Spans._
+import util.SourcePosition
+import tasty.TreePickler.Hole
+import SymUtils._
+import NameKinds._
+import typer.Implicits.SearchFailureType
+
+import scala.collection.mutable
+import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.core.quoted._
+import dotty.tools.dotc.typer.Inliner
+import dotty.tools.dotc.util.SourcePosition
+
+/** A Macrotransform that maintains the necessary infrastructore to support
+ * contxtual staging levels delimited by quotes and splices.
+ */
+abstract class MacroStagingTransform extends MacroTransformWithImplicits {
+ import tpd._
+
+ /** The main transformer class
+ * @param level the current level, where quotes add one and splices subtract one level.
+ * The initial level is 0, a level `l` where `l > 0` implies code has been quoted `l` times
+ * and `l == -1` is code inside a top level splice (in an inline method).
+ * @param levels a stacked map from symbols to the levels in which they were defined
+ */
+ abstract class StagingTransformer extends ImplicitsTransformer {
+
+ /** A map from locally defined symbols to the staging levels of their definitions */
+ val levelOf = new mutable.HashMap[Symbol, Int]
+
+ /** A stack of entered symbols, to be unwound after scope exit */
+ var enteredSyms: List[Symbol] = Nil
+
+ /** Enter staging level of symbol defined by `tree`, if applicable. */
+ def markDef(tree: Tree)(implicit ctx: Context): Unit = tree match {
+ case tree: DefTree =>
+ val sym = tree.symbol
+ if ((sym.isClass || !sym.maybeOwner.isType) && !levelOf.contains(sym)) {
+ levelOf(sym) = quotationLevel
+ enteredSyms = sym :: enteredSyms
+ }
+ case _ =>
+ }
+
+ /** If `tree` refers to a locally defined symbol (either directly, or in a pickled type),
+ * check that its staging level matches the current level. References to types
+ * that are phase-incorrect can still be healed as follows:
+ *
+ * If `T` is a reference to a type at the wrong level, heal it by setting things up
+ * so that we later add a type definition
+ *
+ * type T' = ~quoted.Type[T]
+ *
+ * to the quoted text and rename T to T' in it. This is done later in `reify` via
+ * `addTags`. `checkLevel` itself only records what needs to be done in the
+ * `typeTagOfRef` field of the current `Splice` structure.
+ */
+ protected def checkLevel(tree: Tree)(implicit ctx: Context): Tree
+
+ /** Split `body` into a core and a list of embedded splices.
+ * Then if inside a splice, make a hole from these parts.
+ * If outside a splice, generate a call tp `scala.quoted.Unpickler.unpickleType` or
+ * `scala.quoted.Unpickler.unpickleExpr` that matches `tpe` with
+ * core and splices as arguments.
+ */
+ protected def quotation(body: Tree, quote: Tree)(implicit ctx: Context): Tree
+
+ /** If inside a quote, split the body of the splice into a core and a list of embedded quotes
+ * and make a hole from these parts. Otherwise issue an error, unless we
+ * are in the body of an inline method.
+ */
+ protected def splice(splice: Select)(implicit ctx: Context): Tree
+
+ override def transform(tree: Tree)(implicit ctx: Context): Tree =
+ reporting.trace(i"reify $tree at $quotationLevel", show = true) {
+ def mapOverTree(lastEntered: List[Symbol]) =
+ try super.transform(tree)
+ finally
+ while (enteredSyms ne lastEntered) {
+ levelOf -= enteredSyms.head
+ enteredSyms = enteredSyms.tail
+ }
+ tree match {
+ case Quoted(Spliced(t)) =>
+ transform(t) // '(~x) --> x
+
+ case Quoted(quotedTree) =>
+ quotation(quotedTree, tree)
+
+ case Spliced(Quoted(quotedTree)) =>
+ transform(quotedTree) // ~('x) --> x
+
+ case tree @ Spliced(_) =>
+ splice(tree)
+
+ case tree: RefTree if tree.symbol.is(Inline) && tree.symbol.is(Param) => //TODO remove this case?
+ tree
+
+ case Block(stats, _) =>
+ val last = enteredSyms
+ stats.foreach(markDef)
+ mapOverTree(last)
+
+ case CaseDef(pat, guard, body) =>
+ val last = enteredSyms
+ // mark all bindings
+ new TreeTraverser {
+ def traverse(tree: Tree)(implicit ctx: Context): Unit = {
+ markDef(tree)
+ traverseChildren(tree)
+ }
+ }.traverse(pat)
+ mapOverTree(last)
+
+ case _: Import =>
+ tree
+
+ case _ =>
+ markDef(tree)
+ checkLevel(mapOverTree(enteredSyms))
+ }
+ }
+
+ }
+}