Rename wrongly named liters to capturers

Author: nicolasstucki

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

@@ -73,19 +73,19 @@ class ReifyQuotes extends MacroTransformWithImplicits {
     val levelOf = new mutable.HashMap[Symbol, Int]
 
     /** Register a reference defined in a quote but used in another quote nested in a splice.
-     *  Returns a lifted version of the reference that needs to be used in its place.
+     *  Returns a version of the reference that needs to be used in its place.
      *     '{
      *        val x = ???
      *        { ... '{ ... x ... } ... }.unary_~
      *      }
-     *  Lifting the `x` in `{ ... '{ ... x ... } ... }.unary_~` will return a `x$1.unary_~` for which the `x$1`
+     *  Eta expanding the `x` in `{ ... '{ ... x ... } ... }.unary_~` will return a `x$1.unary_~` for which the `x$1`
      *  be created by some outer reifier.
      *
      *  This transformation is only applied to definitions at staging level 1.
      *
-     *  See `needsLifting`
+     *  See `isCaptured`
      */
-    val lifters = new mutable.HashMap[Symbol, RefTree => Tree]
+    val capturers = new mutable.HashMap[Symbol, RefTree => Tree]
   }
 
   /** The main transformer class
@@ -348,7 +348,7 @@ class ReifyQuotes extends MacroTransformWithImplicits {
      *       { ... '{ ... x$1.unary_~ ... y$1.unary_~ ... } ... }
      *     }
      *
-     *  See: `lift`
+     *  See: `capture`
      *
      *  At the same time register `embedded` trees `x` and `y` to place as arguments of the hole
      *  placed in the original code.
@@ -361,17 +361,17 @@ class ReifyQuotes extends MacroTransformWithImplicits {
     private def makeLambda(tree: Tree)(implicit ctx: Context): Tree = {
       def body(arg: Tree)(implicit ctx: Context): Tree = {
         var i = 0
-        transformWithLifter(tree)(
-          (lifted: mutable.ListBuffer[Tree]) => (tree: RefTree) => {
+        transformWithCapturer(tree)(
+          (captured: mutable.ListBuffer[Tree]) => (tree: RefTree) => {
             val argTpe =
               if (tree.isTerm) defn.QuotedExprType.appliedTo(tree.tpe.widen)
               else defn.QuotedTypeType.appliedTo(defn.AnyType)
             val selectArg = arg.select(nme.apply).appliedTo(Literal(Constant(i))).asInstance(argTpe)
-            val liftedArg = SyntheticValDef(UniqueName.fresh(tree.name.toTermName).toTermName, selectArg)
+            val capturedArg = SyntheticValDef(UniqueName.fresh(tree.name.toTermName).toTermName, selectArg)
             i += 1
             embedded += tree
-            lifted += liftedArg
-            ref(liftedArg.symbol)
+            captured += capturedArg
+            ref(capturedArg.symbol)
           }
         )
       }
@@ -382,21 +382,21 @@ class ReifyQuotes extends MacroTransformWithImplicits {
       Closure(meth, tss => body(tss.head.head)(ctx.withOwner(meth)).changeOwner(ctx.owner, meth))
     }
 
-    private def transformWithLifter(tree: Tree)(
-        lifter: mutable.ListBuffer[Tree] => RefTree => Tree)(implicit ctx: Context): Tree = {
-      val lifted = new mutable.ListBuffer[Tree]
-      val lifter2 = lifter(lifted)
-      outer.enteredSyms.foreach(s => lifters.put(s, lifter2))
+    private def transformWithCapturer(tree: Tree)(
+        capturer: mutable.ListBuffer[Tree] => RefTree => Tree)(implicit ctx: Context): Tree = {
+      val captured = new mutable.ListBuffer[Tree]
+      val captured2 = capturer(captured)
+      outer.enteredSyms.foreach(s => capturers.put(s, captured2))
       val tree2 = transform(tree)
-      lifters --= outer.enteredSyms
-      seq(lifted.result(), tree2)
+      capturers --= outer.enteredSyms
+      seq(captured.result(), tree2)
     }
 
-    /** Returns true if this tree will be lifted by `makeLambda` */
-    private def needsLifting(tree: RefTree)(implicit ctx: Context): Boolean = {
-      // Check phase consistency and presence of lifter
+    /** Returns true if this tree will be captured by `makeLambda` */
+    private def isCaptured(tree: RefTree)(implicit ctx: Context): Boolean = {
+      // Check phase consistency and presence of capturer
       level == 1 && !tree.symbol.is(Inline) && levelOf.get(tree.symbol).contains(1) &&
-      lifters.contains(tree.symbol)
+      capturers.contains(tree.symbol)
     }
 
     /** Transform `tree` and return the resulting tree and all `embedded` quotes
@@ -430,9 +430,9 @@ class ReifyQuotes extends MacroTransformWithImplicits {
             quotation(quotedTree, tree)
           case tree: Select if tree.symbol.isSplice =>
             splice(tree)
-          case tree: RefTree if needsLifting(tree) =>
-            val lift = lifters(tree.symbol)
-            splice(lift(tree).select(if (tree.isTerm) nme.UNARY_~ else tpnme.UNARY_~))
+          case tree: RefTree if isCaptured(tree) =>
+            val capturer = capturers(tree.symbol)
+            splice(capturer(tree).select(if (tree.isTerm) nme.UNARY_~ else tpnme.UNARY_~))
           case Block(stats, _) =>
             val last = enteredSyms
             stats.foreach(markDef)