WIP

Author: nicolasstucki

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

@@ -93,31 +93,27 @@ class Staging extends MacroTransformWithImplicits {
     if (ctx.compilationUnit.needsStaging) super.run
 
   protected def newTransformer(implicit ctx: Context): Transformer =
-    new Reifier(inQuote = false, null, 0, new LevelInfo, ctx)
+    new Reifier(0, new LevelInfo)
 
   private class LevelInfo {
     /** A map from locally defined symbols to the staging levels of their definitions */
     val levelOf = new mutable.HashMap[Symbol, Int]
   }
 
   /** The main transformer class
-   *  @param  inQuote    we are within a `'(...)` context that is not shadowed by a nested `~(...)`
-   *  @param  outer      the next outer reifier, null is this is the topmost transformer
    *  @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
-   *  @param  embedded   a list of embedded quotes (if `inSplice = true`) or splices (if `inQuote = true`
-   *  @param  rctx       the contex in the destination lifted lambda
    */
-  private class Reifier(inQuote: Boolean, val outer: Reifier, val level: Int, levels: LevelInfo, val rctx: Context)
+  private class Reifier(val level: Int, levels: LevelInfo)
       extends ImplicitsTransformer {
     import levels._
     assert(level >= -1)
 
     /** A nested reifier for a quote (if `isQuote = true`) or a splice (if not) */
     def nested(isQuote: Boolean)(implicit ctx: Context): Reifier = {
-      new Reifier(isQuote, this, if (isQuote) level + 1 else level - 1, levels, ctx)
+      new Reifier(if (isQuote) level + 1 else level - 1, levels)
     }
 
     /** A stack of entered symbols, to be unwound after scope exit */
@@ -212,14 +208,9 @@ class Staging extends MacroTransformWithImplicits {
       def apply(tp: Type): Type = reporting.trace(i"check type level $tp at $level") {
         tp match {
           case tp: TypeRef if tp.symbol.isSplice =>
-            if (inQuote) {
-              // TODO add level to checkType TypeMap and avoid accessing the outer one?
-              outer.checkType(pos).mapOver(tp)
-            }
-            else {
-              if (tp.isTerm) ctx.error(i"splice outside quotes", pos)
+              if (tp.isTerm)
+                ctx.error(i"splice outside quotes", pos)
               tp
-            }
           case tp: NamedType =>
             check(tp.symbol, tp, tp.symbol.sourcePos) match {
               case Some(tpRef) => tpRef.tpe