Set positions for constructed trees manually

Author: liufengyun

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

@@ -12,6 +12,7 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with CoreImpl with Helpers
   def TreeDeco(tree: Tree): TreeAPI = new TreeAPI {
     def pos(implicit ctx: Context): Position = tree.sourcePos
     def symbol(implicit ctx: Context): Symbol = tree.symbol
+    def withPos(pos: Position)(implicit ctx: Context): Unit = tree.withSpan(pos.span)
   }
 
   def PackageClauseDeco(pack: PackageClause): PackageClauseAPI = new PackageClauseAPI {

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

@@ -16,13 +16,16 @@ trait TreeUtils {
     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 => body(x.unseal.asInstanceOf[Term.Ident]).seal[U]).unseal
+
+    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))
   }
-
 }

library/src/scala/tasty/reflect/TreeOps.scala

@@ -45,6 +45,13 @@ trait TreeOps extends Core {
     /** Position in the source code */
     def pos(implicit ctx: Context): Position
 
+    /** Set the position of the tree
+     *
+     *  @note It only changes positions, not source file of the tree. Source
+     *        file of trees are derived from context and cannot be changed.
+     */
+    def withPos(pos: Position)(implicit ctx: Context): Unit
+
     def symbol(implicit ctx: Context): Symbol
   }
 

tests/run/reflect-select-constructor/assert_1.scala renamed to tests/run-with-compiler/reflect-select-constructor/assert_1.scala

@@ -14,10 +14,12 @@ object scalatest {
       Type.IsMethodType.unapply(tp).flatMap(tp => if tp.isImplicit then Some(true) else None).nonEmpty
 
     cond.unseal.underlyingArgument match {
-      case Term.Apply(Term.Select(lhs, op), rhs :: Nil) =>
+      case t @ Term.Apply(Term.Select(lhs, op), rhs :: Nil) =>
         let(lhs) { left =>
           let(rhs) { right =>
-            let(Term.Select.overloaded(left, op, Nil, right :: Nil)) { result =>
+            val app = Term.Select.overloaded(left, op, Nil, right :: Nil)
+            app.withPos(t.pos)
+            let(app) { result =>
               val l = left.seal[Any]
               val r = right.seal[Any]
               val b = result.seal[Boolean]
@@ -30,7 +32,9 @@ object scalatest {
       if isImplicitMethodType(f.tpe) =>
         let(lhs) { left =>
           let(rhs) { right =>
-            let(Term.Apply(Term.Select.overloaded(Term.Apply(qual, left :: Nil), op, Nil, right :: Nil), implicits)) { result =>
+            val app = Term.Select.overloaded(Term.Apply(qual, left :: Nil), op, Nil, right :: Nil)
+            app.withPos(f.pos)
+            let(Term.Apply(app, implicits)) { result =>
               val l = left.seal[Any]
               val r = right.seal[Any]
               val b = result.seal[Boolean]