Move let to Block and fix signature

nicolasstucki · nicolasstucki · commit 7006a8e7de0c · 2020-11-05T10:01:49.000+01:00
Rather than remove it as originally planed, we keep it under Block as it creates a block with vals.
Both signatures take an return an Ident now.
diff --git a/library/src/scala/tasty/Reflection.scala b/library/src/scala/tasty/Reflection.scala
@@ -818,6 +818,22 @@ trait Reflection { reflection =>
     /** Creates a block `{ <statements: List[Statement]>; <expr: Term> }` */
     def apply(stats: List[Statement], expr: Term): Block
 
+    /** Creates a block `{ val x = <rhs: Term>; <body(x): Term> }` */
+    def let(rhs: Term)(body: Ident => Term): Term = {
+      val sym = Symbol.newVal(Symbol.currentOwner, "x", rhs.tpe.widen, Flags.EmptyFlags, Symbol.noSymbol)
+      Block(List(ValDef(sym, Some(rhs))), body(Ref(sym).asInstanceOf[Ident]))
+    }
+
+    /** Creates a block `{ val x1 = <terms(0): Term>; ...; val xn = <terms(n-1): Term>; <body(List(x1, ..., xn)): Term> }` */
+    def let(terms: List[Term])(body: List[Ident] => Term): Term = {
+      // TODO implement efficitent flat version
+      def rec(xs: List[Term], acc: List[Ident]): Term = xs match {
+        case Nil => body(acc)
+        case x :: xs => let(x) { (x: Ident) => rec(xs, x :: acc) }
+      }
+      rec(terms, Nil)
+    }
+
     def copy(original: Tree)(stats: List[Statement], expr: Term): Block
 
     /** Matches a block `{ <statements: List[Statement]>; <expr: Term> }` */
@@ -3329,22 +3345,4 @@ trait Reflection { reflection =>
     val reflect: reflection.type = reflection
   }
 
-  // TODO: extract from Reflection
-
-  /** Bind the `rhs` to a `val` and use it in `body` */
-  def let(rhs: Term)(body: Ident => Term): Term = {
-    val sym = Symbol.newVal(Symbol.currentOwner, "x", rhs.tpe.widen, Flags.EmptyFlags, Symbol.noSymbol)
-    Block(List(ValDef(sym, Some(rhs))), body(Ref(sym).asInstanceOf[Ident]))
-  }
-
-  /** Bind the given `terms` to names and use them in the `body` */
-  def lets(terms: List[Term])(body: List[Term] => Term): Term = {
-    def rec(xs: List[Term], acc: List[Term]): Term = xs match {
-      case Nil => body(acc)
-      case x :: xs => let(x) { (x: Term) => rec(xs, x :: acc) }
-    }
-    rec(terms, Nil)
-  }
-
-
 }
diff --git a/tests/pos-macros/i6535/Macro_1.scala b/tests/pos-macros/i6535/Macro_1.scala
@@ -10,10 +10,10 @@ object scalatest {
 
     cond.unseal.underlyingArgument match {
       case t @ Apply(Select(lhs, op), rhs :: Nil) =>
-        let(lhs) { left =>
-          let(rhs) { right =>
+        Block.let(lhs) { left =>
+          Block.let(rhs) { right =>
             val app = Select.overloaded(left, op, Nil, right :: Nil)
-            let(app) { result =>
+            Block.let(app) { result =>
               val l = left.seal
               val r = right.seal
               val b = result.seal.cast[Boolean]
diff --git a/tests/pos-macros/i8866/Macro_1.scala b/tests/pos-macros/i8866/Macro_1.scala
@@ -14,7 +14,7 @@ object Macro {
   def impl(using qctx: QuoteContext): Expr[Int] = {
     import qctx.reflect._
 
-    let(
+    Block.let(
       Select.unique(
         '{ OtherMacro }.unseal,
         "apply"
diff --git a/tests/pos-macros/i8866b/Macro_1.scala b/tests/pos-macros/i8866b/Macro_1.scala
@@ -9,7 +9,7 @@ object Macro {
   def impl(using qctx: QuoteContext): Expr[Int] = {
     import qctx.reflect._
 
-    let(
+    Block.let(
       Select.unique(
         '{ Other }.unseal,
         "apply"
diff --git a/tests/run-macros/i6171/Macro_1.scala b/tests/run-macros/i6171/Macro_1.scala
@@ -14,10 +14,10 @@ object scalatest {
 
     cond.unseal.underlyingArgument match {
       case t @ Apply(Select(lhs, op), rhs :: Nil) =>
-        let(lhs) { left =>
-          let(rhs) { right =>
+        Block.let(lhs) { left =>
+          Block.let(rhs) { right =>
             val app = Select.overloaded(left, op, Nil, right :: Nil)
-            let(app) { result =>
+            Block.let(app) { result =>
               val l = left.seal
               val r = right.seal
               val b = result.seal.cast[Boolean]
@@ -28,10 +28,10 @@ object scalatest {
         }.seal.cast[Unit]
       case Apply(f @ Apply(Select(Apply(qual, lhs :: Nil), op), rhs :: Nil), implicits)
         if isImplicitMethodType(f.tpe) =>
-        let(lhs) { left =>
-          let(rhs) { right =>
+        Block.let(lhs) { left =>
+          Block.let(rhs) { right =>
             val app = Select.overloaded(Apply(qual, left :: Nil), op, Nil, right :: Nil)
-            let(Apply(app, implicits)) { result =>
+            Block.let(Apply(app, implicits)) { result =>
               val l = left.seal
               val r = right.seal
               val b = result.seal.cast[Boolean]
diff --git a/tests/run-macros/reflect-dsl/assert_1.scala b/tests/run-macros/reflect-dsl/assert_1.scala
@@ -14,10 +14,10 @@ object scalatest {
 
     cond.unseal.underlyingArgument match {
       case t @ Apply(sel @ Select(lhs, op), rhs :: Nil) =>
-        let(lhs) { left =>
-          let(rhs) { right =>
+        Block.let(lhs) { left =>
+          Block.let(rhs) { right =>
             val app = left.select(sel.symbol).appliedTo(right)
-            let(app) { result =>
+            Block.let(app) { result =>
               val l = left.seal
               val r = right.seal
               val b = result.seal.cast[Boolean]
@@ -28,10 +28,10 @@ object scalatest {
         }.seal.cast[Unit]
       case Apply(f @ Apply(sel @ Select(Apply(qual, lhs :: Nil), op), rhs :: Nil), implicits)
       if isImplicitMethodType(f.tpe) =>
-        let(lhs) { left =>
-          let(rhs) { right =>
+        Block.let(lhs) { left =>
+          Block.let(rhs) { right =>
             val app = qual.appliedTo(left).select(sel.symbol).appliedTo(right)
-            let(Apply(app, implicits)) { result =>
+            Block.let(Apply(app, implicits)) { result =>
               val l = left.seal
               val r = right.seal
               val b = result.seal.cast[Boolean]
diff --git a/tests/run-macros/reflect-pos-fun/assert_1.scala b/tests/run-macros/reflect-pos-fun/assert_1.scala
@@ -10,8 +10,8 @@ object scalatest {
 
     cond.unseal.underlyingArgument match {
       case t @ Apply(TypeApply(Select(lhs, op), targs), rhs) =>
-        let(lhs) { left =>
-          lets(rhs) { rs =>
+        Block.let(lhs) { left =>
+          Block.let(rhs) { rs =>
             val app = Select.overloaded(left, op, targs.map(_.tpe), rs)
             val b = app.seal.cast[Boolean]
             '{ scala.Predef.assert($b) }.unseal
diff --git a/tests/run-macros/reflect-select-constructor/assert_1.scala b/tests/run-macros/reflect-select-constructor/assert_1.scala
@@ -14,10 +14,10 @@ object scalatest {
 
     cond.unseal.underlyingArgument match {
       case t @ Apply(Select(lhs, op), rhs :: Nil) =>
-        let(lhs) { left =>
-          let(rhs) { right =>
+        Block.let(lhs) { left =>
+          Block.let(rhs) { right =>
             val app = Select.overloaded(left, op, Nil, right :: Nil)
-            let(app) { result =>
+            Block.let(app) { result =>
               val l = left.seal
               val r = right.seal
               val b = result.seal.cast[Boolean]
@@ -28,10 +28,10 @@ object scalatest {
         }.seal.cast[Unit]
       case Apply(f @ Apply(Select(Apply(qual, lhs :: Nil), op), rhs :: Nil), implicits)
       if isImplicitMethodType(f.tpe) =>
-        let(lhs) { left =>
-          let(rhs) { right =>
+        Block.let(lhs) { left =>
+          Block.let(rhs) { right =>
             val app = Select.overloaded(Apply(qual, left :: Nil), op, Nil, right :: Nil)
-            let(Apply(app, implicits)) { result =>
+            Block.let(Apply(app, implicits)) { result =>
               val l = left.seal
               val r = right.seal
               val b = result.seal.cast[Boolean]
diff --git a/tests/run-macros/reflect-select-copy-2/assert_1.scala b/tests/run-macros/reflect-select-copy-2/assert_1.scala
@@ -14,9 +14,9 @@ object scalatest {
 
     cond.unseal.underlyingArgument match {
       case Apply(sel @ Select(lhs, op), rhs :: Nil) =>
-        let(lhs) { left =>
-          let(rhs) { right =>
-            let(Apply(Select.copy(sel)(left, op), right :: Nil)) { result =>
+        Block.let(lhs) { left =>
+          Block.let(rhs) { right =>
+            Block.let(Apply(Select.copy(sel)(left, op), right :: Nil)) { result =>
               val l = left.seal
               val r = right.seal
               val b = result.seal.cast[Boolean]
@@ -27,9 +27,9 @@ object scalatest {
         }.seal.cast[Unit]
       case Apply(f @ Apply(sel @ Select(Apply(qual, lhs :: Nil), op), rhs :: Nil), implicits)
       if isImplicitMethodType(f.tpe) =>
-        let(lhs) { left =>
-          let(rhs) { right =>
-            let(Apply(Apply(Select.copy(sel)(Apply(qual, left :: Nil), op), right :: Nil), implicits)) { result =>
+        Block.let(lhs) { left =>
+          Block.let(rhs) { right =>
+            Block.let(Apply(Apply(Select.copy(sel)(Apply(qual, left :: Nil), op), right :: Nil), implicits)) { result =>
               val l = left.seal
               val r = right.seal
               val b = result.seal.cast[Boolean]
diff --git a/tests/run-macros/reflect-select-symbol-constructor/assert_1.scala b/tests/run-macros/reflect-select-symbol-constructor/assert_1.scala
@@ -14,10 +14,10 @@ object scalatest {
 
     cond.unseal.underlyingArgument match {
       case t @ Apply(sel @ Select(lhs, op), rhs :: Nil) =>
-        let(lhs) { left =>
-          let(rhs) { right =>
+        Block.let(lhs) { left =>
+          Block.let(rhs) { right =>
             val app = Apply(Select(left, sel.symbol), right :: Nil)
-            let(app) { result =>
+            Block.let(app) { result =>
               val l = left.seal
               val r = right.seal
               val b = result.seal.cast[Boolean]
@@ -28,10 +28,10 @@ object scalatest {
         }.seal.cast[Unit]
       case Apply(f @ Apply(sel @ Select(Apply(qual, lhs :: Nil), op), rhs :: Nil), implicits)
       if isImplicitMethodType(f.tpe) =>
-        let(lhs) { left =>
-          let(rhs) { right =>
+        Block.let(lhs) { left =>
+          Block.let(rhs) { right =>
             val app = Apply(Select(Apply(qual, left :: Nil), sel.symbol), right :: Nil)
-            let(Apply(app, implicits)) { result =>
+            Block.let(Apply(app, implicits)) { result =>
               val l = left.seal
               val r = right.seal
               val b = result.seal.cast[Boolean]
diff --git a/tests/run-macros/reflect-select-value-class/assert_1.scala b/tests/run-macros/reflect-select-value-class/assert_1.scala
@@ -14,10 +14,10 @@ object scalatest {
 
     cond.unseal.underlyingArgument match {
       case t @ Apply(Select(lhs, op), rhs :: Nil) =>
-        let(lhs) { left =>
-          let(rhs) { right =>
+        Block.let(lhs) { left =>
+          Block.let(rhs) { right =>
             val app = Select.overloaded(left, op, Nil, right :: Nil)
-            let(app) { result =>
+            Block.let(app) { result =>
               val l = left.seal
               val r = right.seal
               val b = result.seal.cast[Boolean]
@@ -28,10 +28,10 @@ object scalatest {
         }.seal.cast[Unit]
       case Apply(f @ Apply(Select(Apply(qual, lhs :: Nil), op), rhs :: Nil), implicits)
       if isImplicitMethodType(f.tpe) =>
-        let(lhs) { left =>
-          let(rhs) { right =>
+        Block.let(lhs) { left =>
+          Block.let(rhs) { right =>
             val app = Select.overloaded(Apply(qual, left :: Nil), op, Nil, right :: Nil)
-            let(Apply(app, implicits)) { result =>
+            Block.let(Apply(app, implicits)) { result =>
               val l = left.seal
               val r = right.seal
               val b = result.seal.cast[Boolean]
diff --git a/tests/run-macros/tasty-unsafe-let/quoted_1.scala b/tests/run-macros/tasty-unsafe-let/quoted_1.scala
@@ -10,8 +10,8 @@ object Macros {
 
     val rhsTerm = rhs.unseal
 
-    import qctx.reflect.{let => letTerm}
-    letTerm(rhsTerm) { rhsId =>
+    import qctx.reflect._
+    Block.let(rhsTerm) { rhsId =>
       Expr.betaReduce('{$body(${rhsId.seal.asInstanceOf[Expr[T]]})}).unseal // Dangerous uncheked cast!
     }.seal.cast[Unit]
   }

Original file line number	Diff line number	Diff line change
`@@ -10,8 +10,8 @@ object Macros {`
`10`	`10`
`11`	`11`	`val rhsTerm = rhs.unseal`
`12`	`12`
`13`		`- import qctx.reflect.{let => letTerm}`
`14`		`- letTerm(rhsTerm) { rhsId =>`
	`13`	`+ import qctx.reflect._`
	`14`	`+ Block.let(rhsTerm) { rhsId =>`
`15`	`15`	`Expr.betaReduce('{$body(${rhsId.seal.asInstanceOf[Expr[T]]})}).unseal // Dangerous uncheked cast!`
`16`	`16`	`}.seal.cast[Unit]`
`17`	`17`	`}`