Fix rebase errors

Author: liufengyun

library/src-bootstrapped/scala/tasty/reflect/utils/TreeUtils.scala

@@ -9,23 +9,17 @@ trait TreeUtils {
   import reflect._
 
   /** Bind the `rhs` to a `val` and use it in `body` */
-  def let(rhs: Term)(bodyType: Type)(body: Term.Ident => Term): Term = {
-    // Recover all lost type information
+  def let(rhs: Term)(body: Term.Ident => Term): Term = {
     type T // TODO probably it is better to use the Sealed contruct rather than let the user create their own existential type
-    type U // TODO probably it is better to use the Sealed contruct rather than let the user create their own existential type
-    implicit val bodyTpe: quoted.Type[U] = bodyType.seal.asInstanceOf[quoted.Type[U]]
     implicit val rhsTpe: quoted.Type[T] = rhs.tpe.seal.asInstanceOf[quoted.Type[T]]
     val rhsExpr = rhs.seal[T]
-
-    let[T, U](rhsExpr) { x =>
-      val id = ('(x)).unseal.asInstanceOf[Term.Ident]
-      id.withPos(rhs.pos)
-      body(id).seal[U]
-    }.unseal
-  }
-
-  private def let[T: quoted.Type, U: quoted.Type](rhs: Expr[T])(in: Expr[T] => Expr[U]): Expr[U] = '{
-    val x = ~rhs
-    ~in('(x))
+    val expr = '{
+      val x = ~rhsExpr
+      ~{
+        val id = ('(x)).unseal.asInstanceOf[Term.Ident]
+        body(id).seal[Any]
+      }
+    }
+    expr.unseal
   }
 }

tests/run-with-compiler/reflect-select-copy/assert_1.scala

@@ -15,9 +15,9 @@ object scalatest {
 
     cond.unseal.underlyingArgument match {
       case Term.Apply(sel @ Term.Select(lhs, op), rhs :: Nil) =>
-        let(lhs)(definitions.UnitType) { left =>
-          let(rhs)(definitions.UnitType) { right =>
-            let(Term.Apply(Term.Select.copy(sel)(left, op), right :: Nil))(definitions.UnitType) { result =>
+        let(lhs) { left =>
+          let(rhs) { right =>
+            let(Term.Apply(Term.Select.copy(sel)(left, op), right :: Nil)) { result =>
               val l = left.seal[Any]
               val r = right.seal[Any]
               val b = result.seal[Boolean]
@@ -28,9 +28,9 @@ object scalatest {
         }.seal[Unit]
       case Term.Apply(f @ Term.Apply(Term.IsSelect(sel @ Term.Select(Term.Apply(qual, lhs :: Nil), op)), rhs :: Nil), implicits)
       if isImplicitMethodType(f.tpe) =>
-        let(lhs)(definitions.UnitType) { left =>
-          let(rhs)(definitions.UnitType) { right =>
-            let(Term.Apply(Term.Apply(Term.Select.copy(sel)(Term.Apply(qual, left :: Nil), op), right :: Nil), implicits))(definitions.UnitType) { result =>
+        let(lhs) { left =>
+          let(rhs) { right =>
+            let(Term.Apply(Term.Apply(Term.Select.copy(sel)(Term.Apply(qual, left :: Nil), op), right :: Nil), implicits)) { result =>
               val l = left.seal[Any]
               val r = right.seal[Any]
               val b = result.seal[Boolean]

tests/run-with-compiler/tasty-unsafe-let/quoted_1.scala

@@ -13,7 +13,7 @@ object Macros {
     val rhsTerm = rhs.unseal
 
     import reflect.util.{let => letTerm}
-    letTerm(rhsTerm)(('[Unit]).unseal.tpe) { rhsId =>
+    letTerm(rhsTerm) { rhsId =>
       body(rhsId.seal[Any].asInstanceOf[Expr[T]]).unseal // Dangerous uncheked cast!
     }.seal[Unit]
   }