Add let abstractions with customizable and fresh names

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tastyreflect/QuoteContextState.scala

@@ -0,0 +1,22 @@
+package dotty.tools.dotc.tastyreflect
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core._
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.util.Property
+
+object QuoteContextState {
+
+  val NextIndex = new Property.Key[scala.runtime.IntRef]
+
+  def init(ctx: Context): Context =
+    ctx.fresh.setProperty(NextIndex, new scala.runtime.IntRef(0))
+
+  def nextIndex()(given ctx: Context): Int = {
+    val ref = ctx.property(NextIndex).get
+    val ret = ref.elem
+    ref.elem = ret + 1
+    ret
+  }
+}
+

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala

@@ -12,6 +12,7 @@ import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Types.SingletonType
 import dotty.tools.dotc.tastyreflect.FromSymbol.{definitionFromSym, packageDefFromSym}
+import dotty.tools.dotc.tastyreflect.QuoteContextState
 import dotty.tools.dotc.typer.Implicits.{AmbiguousImplicits, DivergingImplicit, NoMatchingImplicits, SearchFailure, SearchFailureType}
 import dotty.tools.dotc.util.{SourceFile, SourcePosition, Spans}
 
@@ -28,6 +29,8 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   def rootPosition: util.SourcePosition =
     tastyreflect.MacroExpansion.position.getOrElse(SourcePosition(rootContext.source, Spans.NoSpan))
 
+  def nextIndex(): Int = QuoteContextState.nextIndex()
+
   //
   // QUOTE UNPICKLING
   //

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

@@ -1236,7 +1236,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
   private def expandMacro(body: Tree, span: Span)(implicit ctx: Context) = {
     assert(level == 0)
     val inlinedFrom = enclosingInlineds.last
-    val ctx1 = tastyreflect.MacroExpansion.context(inlinedFrom)
+    val ctx1 = tastyreflect.QuoteContextState.init(tastyreflect.MacroExpansion.context(inlinedFrom))
 
     val dependencies = macroDependencies(body)
 

docs/docs/reference/metaprogramming/macros.md

@@ -564,6 +564,52 @@ while (i < arr.length) {
 }
 sum
 ```
+### Showing meaningful definition names in quotes
+
+In the `powerCode` example above there is a `'{ val y = $x * $x; ... }` which when printed
+may show several different `val y = ...`.
+
+For example
+```scala
+powerCode(16, '{7}).show
+```
+will show
+```scala
+val y: scala.Double = 7
+val y: scala.Double = y.*(y)
+val y: scala.Double = y.*(y)
+val y: scala.Double = y.*(y)
+val y: scala.Double = y.*(y)
+y
+```
+Even though there is no hygiene issue it may be hard to undestand the code. To overcome this inconvenience
+each `y` can be assigned a meaningful name using the `scala.quoted.util.let`.
+For example `let("y" + i)('{ $x * $x })(yi => ...)` will assign to each `y` a name
+`y{i}` where `{i}` is a known String, if `i == 3` then it would be named `y3`.
+
+The `powerCode` can be defined as follows using `showName`
+```scala
+def powerCodeD(n: Long, x: Expr[Double]))(given QuoteContext): Expr[Double] =
+  let("y1")(x)(y1 => powerCodeD(n, 2, y1))
+
+def powerCodeD(n: Long, i: Int, x: Expr[Double])(given QuoteContext): Expr[Double] =
+  if (n == 0) '{1.0}
+  else if (n % 2 == 0) let("y" + i)('{ $x * $x })(ai => powerCodeD(n / 2, idx * 2, yi) }
+  else '{ $x * ${powerCodeD(n - 1, idx, x)} }
+```
+then
+```scala
+powerCodeD(16, '{7}).show
+```
+will show
+```scala
+val y1: scala.Double = 7
+val y2: scala.Double = y1.*(y1)
+val y4: scala.Double = y2.*(y2)
+val y8: scala.Double = y4.*(y4)
+val y16: scala.Double = y8.*(y8)
+a16
+```
 
 ### Find implicits within a macro
 

library/src-bootstrapped/scala/quoted/util/package.scala

@@ -0,0 +1,17 @@
+package scala.quoted
+
+import scala.internal.quoted.showName
+
+package object util {
+
+  /** Genrate the code `'{ val `<name>` = $expr; ${ body('<name>) } }` with the given name */
+  def let[T: Type, U: Type](name: String)(expr: Expr[T])(body: Expr[T] => Expr[U])(given QuoteContext): Expr[U] = '{
+     @showName(${Expr(name)}) val x = $expr
+     ${ body('x) }
+  }
+
+  /** Genrate the code `'{ val x$<i> = $expr; ${ body('x$<i>) } }` for a fresh i */
+  def let[T: Type, U: Type](expr: Expr[T])(body: Expr[T] => Expr[U])(given qctx: QuoteContext): Expr[U] =
+    let("x$" + qctx.nextIndex())(expr)(body)
+
+}

library/src/scala/quoted/QuoteContext.scala

@@ -46,6 +46,12 @@ class QuoteContext(val tasty: scala.tasty.Reflection) {
     tasty.warning(msg, expr.unseal.pos)(given rootContext)
   }
 
+  /** Get a fresh index within the scope of this quote context.
+   *  Each `scala.quoted.staging.run` and macro expansion starts with the next index at 0.
+   */
+  def nextIndex(): Int =
+    tasty.internal.nextIndex()
+
 }
 
 object QuoteContext {

library/src/scala/tasty/reflect/CompilerInterface.scala

@@ -117,6 +117,8 @@ trait CompilerInterface {
 
   def settings: Settings
 
+  def nextIndex(): Int
+
   //
   // QUOTE UNPICKLING
   //

staging/src/scala/quoted/staging/QuoteDriver.scala

@@ -4,7 +4,7 @@ package staging
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.Driver
 import dotty.tools.dotc.core.Contexts.{Context, ContextBase, FreshContext}
-import dotty.tools.dotc.tastyreflect.ReflectionImpl
+import dotty.tools.dotc.tastyreflect.{ReflectionImpl, QuoteContextState}
 import dotty.tools.io.{AbstractFile, Directory, PlainDirectory, VirtualDirectory}
 import dotty.tools.repl.AbstractFileClassLoader
 import dotty.tools.dotc.reporting._
@@ -32,7 +32,7 @@ private class QuoteDriver(appClassloader: ClassLoader) extends Driver {
     }
 
     val (_, ctx0: Context) = setup(settings.compilerArgs.toArray :+ "dummy.scala", initCtx.fresh)
-    val ctx = setToolboxSettings(ctx0.fresh.setSetting(ctx0.settings.outputDir, outDir), settings)
+    val ctx = setToolboxSettings(QuoteContextState.init(ctx0).fresh.setSetting(ctx0.settings.outputDir, outDir), settings)
 
     new QuoteCompiler().newRun(ctx).compileExpr(exprBuilder) match {
       case Right(value) =>

tests/run-macros/quoted-let-name-3.check

@@ -0,0 +1,23 @@
+Test.x.*({
+   val x$0: scala.Double = Test.x.*(Test.x)
+   val x$1: scala.Double = x$0.*(x$0)
+  x$1.*({
+     val x$2: scala.Double = x$1.*(x$1)
+    x$2.*({
+       val x$3: scala.Double = x$2.*(x$2)
+       val x$4: scala.Double = x$3.*(x$3)
+       val x$5: scala.Double = x$4.*(x$4)
+      x$5
+    })
+  })
+})
+Test.x.*({
+   val x$0: scala.Double = Test.x.*(Test.x)
+  x$0.*({
+     val x$1: scala.Double = x$0.*(x$0)
+     val x$2: scala.Double = x$1.*(x$1)
+     val x$3: scala.Double = x$2.*(x$2)
+     val x$4: scala.Double = x$3.*(x$3)
+    x$4
+  })
+})

tests/run-macros/quoted-let-name-3/Macro_1.scala

@@ -0,0 +1,14 @@
+import scala.quoted._
+import scala.quoted.util.let
+
+inline def power(x: Double, inline n: Long): String =
+  ${ powerCodeShow('x, n) }
+
+private def powerCodeShow(x: Expr[Double], n: Long)(given QuoteContext): Expr[String] =
+  Expr(powerCode(n, 2, x).show)
+
+private def powerCode(n: Long, idx: Int, x: Expr[Double])(given QuoteContext): Expr[Double] =
+  if (n == 0) '{1.0}
+  else if (n == 1) x
+  else if (n % 2 == 0) let('{ $x * $x })(y => powerCode(n / 2, idx * 2, y))
+  else '{ $x * ${powerCode(n - 1, idx, x)} }

tests/run-macros/quoted-let-name-3/Test_2.scala

@@ -0,0 +1,8 @@
+
+
+
+object Test extends App {
+  val x = 4.5
+  println(power(x, 77))
+  println(power(x, 35))
+}

tests/run-staging/quoted-let-name-1.check

@@ -0,0 +1,13 @@
+((x: scala.Double) => x.*({
+   val x$0: scala.Double = x.*(x)
+   val x$1: scala.Double = x$0.*(x$0)
+  x$1.*({
+     val x$2: scala.Double = x$1.*(x$1)
+    x$2.*({
+       val x$3: scala.Double = x$2.*(x$2)
+       val x$4: scala.Double = x$3.*(x$3)
+       val x$5: scala.Double = x$4.*(x$4)
+      x$5
+    })
+  })
+}))

tests/run-staging/quoted-let-name-1.scala

@@ -0,0 +1,20 @@
+import scala.quoted._
+import scala.quoted.util.let
+import scala.quoted.staging._
+
+object Test {
+  given Toolbox = Toolbox.make(getClass.getClassLoader)
+  def main(args: Array[String]): Unit = withQuoteContext {
+    println(powerCode(77).show)
+  }
+
+  def powerCode(n: Long)(given QuoteContext): Expr[Double => Double] =
+    '{ x => ${powerCode(n, 2, 'x)} }
+
+  def powerCode(n: Long, idx: Int, x: Expr[Double])(given QuoteContext): Expr[Double] =
+    if (n == 0) '{1.0}
+    else if (n == 1) x
+    else if (n % 2 == 0) let('{ $x * $x })(y => powerCode(n / 2, idx * 2, y))
+    else '{ $x * ${powerCode(n - 1, idx, x)} }
+
+}

tests/run-staging/quoted-let-name-2.check

@@ -0,0 +1,13 @@
+((x1: scala.Double) => x1.*({
+   val x2: scala.Double = x1.*(x1)
+   val x4: scala.Double = x2.*(x2)
+  x4.*({
+     val x8: scala.Double = x4.*(x4)
+    x8.*({
+       val x16: scala.Double = x8.*(x8)
+       val x32: scala.Double = x16.*(x16)
+       val x64: scala.Double = x32.*(x32)
+      x64
+    })
+  })
+}))

tests/run-staging/quoted-let-name-2.scala

@@ -0,0 +1,20 @@
+import scala.quoted._
+import scala.quoted.util.let
+import scala.quoted.staging._
+
+object Test {
+  given Toolbox = Toolbox.make(getClass.getClassLoader)
+  def main(args: Array[String]): Unit = withQuoteContext {
+    println(powerCode(77).show)
+  }
+
+  def powerCode(n: Long)(given QuoteContext): Expr[Double => Double] =
+    '{ x1 => ${powerCode(n, 2, 'x1)} }
+
+  def powerCode(n: Long, idx: Int, x: Expr[Double])(given QuoteContext): Expr[Double] =
+    if (n == 0) '{1.0}
+    else if (n == 1) x
+    else if (n % 2 == 0) let(s"x$idx")('{ $x * $x })(y => powerCode(n / 2, idx * 2, y))
+    else '{ $x * ${powerCode(n - 1, idx, x)} }
+
+}