Add path to allow setting sources togethet with spans in Positioned

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -1379,7 +1379,7 @@ object desugar {
     mayNeedSetter
   }
 
-  private def derivedDefDef(original: Tree, named: NameTree, tpt: Tree, rhs: Tree, mods: Modifiers)(implicit src: SourceFile) =
+  private def derivedDefDef(original: Tree, named: NameTree, tpt: Tree, rhs: Tree, mods: Modifiers)(using Context) =
     DefDef(named.name.asTermName, Nil, Nil, tpt, rhs)
       .withMods(mods)
       .withSpan(original.span.withPoint(named.span.start))

compiler/src/dotty/tools/dotc/ast/Positioned.scala

@@ -46,32 +46,41 @@ abstract class Positioned(implicit @constructorOnly src: SourceFile) extends Src
   uniqueId = src.nextId
   span = envelope(src)
 
-  val source: SourceFile = src
+  private var mySource: SourceFile = src
+
+  def source: SourceFile = mySource
+  def source_=(x: SourceFile): Unit = { mySource = x }
+
   def sourcePos(using Context): SourcePosition = source.atSpan(span)
 
   /** This positioned item, widened to `SrcPos`. Used to make clear we only need the
    *  position, typically for error reporting.
    */
   final def srcPos: SrcPos = this
 
+  def withSpanAndSource(span: Span, src: SourceFile): this.type =
+    if mySpan == span && (source eq src) then this
+    else
+      val newpd: this.type =
+        if mySpan.isSynthetic then
+          if !mySpan.exists && span.exists then
+            envelope(src, span.startPos) // fill in children spans
+          this
+        else cloned
+      newpd.span = span
+      newpd.source = src
+      newpd
+
   /** A positioned item like this one with given `span`.
    *  If the positioned item is source-derived, a clone is returned.
    *  If the positioned item is synthetic, the position is updated
    *  destructively and the item itself is returned.
    */
-  def withSpan(span: Span): this.type =
-    if (span == mySpan) this
-    else {
-      val newpd: this.type =
-        if (mySpan.isSynthetic) {
-          if (!mySpan.exists && span.exists)
-            envelope(source, span.startPos) // fill in children spans
-          this
-        }
-        else cloneIn(source)
-      newpd.span = span
-      newpd
-    }
+  def withSpan(span: Span)(using Context): this.type =
+    withSpanAndSource(span, source)
+
+  def withSourcePos(pos: SourcePosition): this.type =
+    withSpanAndSource(pos.span, pos.source)
 
   /** The union of startSpan and the spans of all positioned children that
    *  have the same source as this node, except that Inlined nodes only
@@ -130,6 +139,11 @@ abstract class Positioned(implicit @constructorOnly src: SourceFile) extends Src
     newpd
   }
 
+  def cloned: this.type =
+    val newpd: this.type = clone.asInstanceOf[this.type]
+    newpd.uniqueId = source.nextId
+    newpd
+
   def contains(that: Positioned): Boolean = {
     def isParent(x: Any): Boolean = x match {
       case x: Positioned =>

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -853,21 +853,21 @@ object Trees {
         case nil => s
       combine(NoSpan, trees)
 
-    override def withSpan(span: Span): this.type =
+    override def withSpan(span: Span)(using Context): this.type =
       mapElems(_.withSpan(span)).asInstanceOf[this.type]
   }
 
   class EmptyTree[T >: Untyped] extends Thicket(Nil)(NoSource) {
     // assert(uniqueId != 1492)
-    override def withSpan(span: Span) = throw AssertionError("Cannot change span of EmptyTree")
+    override def withSpan(span: Span)(using Context) = throw AssertionError("Cannot change span of EmptyTree")
   }
 
   class EmptyValDef[T >: Untyped] extends ValDef[T](
     nme.WILDCARD, genericEmptyTree[T], genericEmptyTree[T])(NoSource) with WithoutTypeOrPos[T] {
     myTpe = NoType.asInstanceOf[T]
     setMods(untpd.Modifiers(PrivateLocal))
     override def isEmpty: Boolean = true
-    override def withSpan(span: Span) = throw AssertionError("Cannot change span of EmptyValDef")
+    override def withSpan(span: Span)(using Context) = throw AssertionError("Cannot change span of EmptyValDef")
   }
 
   @sharable val theEmptyTree = new EmptyTree[Type]()
@@ -1028,11 +1028,11 @@ object Trees {
 
       protected def finalize(tree: Tree, copied: untpd.Tree): copied.ThisTree[T] =
         Stats.record(s"TreeCopier.finalize/${tree.getClass == copied.getClass}")
-        postProcess(tree, copied.withSpan(tree.span).withAttachmentsFrom(tree))
+        postProcess(tree, copied.withSpanAndSource(tree.span, copied.source).withAttachmentsFrom(tree))
 
       protected def finalize(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[T] =
         Stats.record(s"TreeCopier.finalize/${tree.getClass == copied.getClass}")
-        postProcess(tree, copied.withSpan(tree.span).withAttachmentsFrom(tree))
+        postProcess(tree, copied.withSpanAndSource(tree.span, copied.source).withAttachmentsFrom(tree))
 
       def Ident(tree: Tree)(name: Name)(using Context): Ident = tree match {
         case tree: Ident if name == tree.name => tree