Drop withPosOf and withSourcePos

Replace by withSpan

Author: odersky

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

@@ -113,7 +113,7 @@ object desugar {
   def derivedTypeParam(tdef: TypeDef, suffix: String = "")(implicit ctx: Context): TypeDef =
     cpy.TypeDef(tdef)(
       name = tdef.name ++ suffix,
-      rhs = new DerivedFromParamTree(suffix).withPosOf(tdef.rhs).watching(tdef)
+      rhs = new DerivedFromParamTree(suffix).withSpan(tdef.rhs.span).watching(tdef)
     )
 
   /** A derived type definition watching `sym` */
@@ -123,7 +123,7 @@ object desugar {
   /** A value definition copied from `vdef` with a tpt typetree derived from it */
   def derivedTermParam(vdef: ValDef)(implicit ctx: Context): ValDef =
     cpy.ValDef(vdef)(
-      tpt = new DerivedFromParamTree("").withPosOf(vdef.tpt).watching(vdef))
+      tpt = new DerivedFromParamTree("").withSpan(vdef.tpt.span).watching(vdef))
 
 // ----- Desugar methods -------------------------------------------------
 
@@ -564,7 +564,7 @@ object desugar {
         ModuleDef(
           className.toTermName, Template(emptyConstructor, parentTpt :: Nil, EmptyValDef, defs))
             .withMods(companionMods | Synthetic))
-      .withPosOf(cdef).toList
+      .withSpan(cdef.span).toList
 
     val companionMembers = defaultGetters ::: eqInstances ::: enumCases
 
@@ -653,7 +653,7 @@ object desugar {
         // we can reuse the constructor parameters; no derived params are needed.
         DefDef(className.toTermName, constrTparams, constrVparamss, classTypeRef, creatorExpr)
           .withMods(companionMods | Synthetic | Implicit)
-          .withPosOf(cdef) :: Nil
+          .withSpan(cdef.span) :: Nil
 
     val self1 = {
       val selfType = if (self.tpt.isEmpty) classTypeRef else self.tpt
@@ -720,7 +720,7 @@ object desugar {
       val clsTmpl = cpy.Template(impl)(self = clsSelf, body = impl.body)
       val cls = TypeDef(clsName, clsTmpl)
         .withMods(mods.toTypeFlags & RetainedModuleClassFlags | ModuleClassCreationFlags)
-      Thicket(modul, classDef(cls).withPosOf(mdef))
+      Thicket(modul, classDef(cls).withSpan(mdef.span))
     }
   }
 
@@ -856,7 +856,7 @@ object desugar {
   /** Expand variable identifier x to x @ _ */
   def patternVar(tree: Tree)(implicit ctx: Context): Bind = {
     val Ident(name) = tree
-    Bind(name, Ident(nme.WILDCARD)).withPosOf(tree)
+    Bind(name, Ident(nme.WILDCARD)).withSpan(tree.span)
   }
 
   def defTree(tree: Tree)(implicit ctx: Context): Tree = tree match {
@@ -988,7 +988,7 @@ object desugar {
     val vdefs =
       params.zipWithIndex.map{
         case (param, idx) =>
-          DefDef(param.name, Nil, Nil, TypeTree(), selector(idx)).withPosOf(param)
+          DefDef(param.name, Nil, Nil, TypeTree(), selector(idx)).withSpan(param.span)
       }
     Function(param :: Nil, Block(vdefs, body))
   }
@@ -1282,7 +1282,7 @@ object desugar {
               finalizer)
         }
     }
-    desugared.withPosOf(tree)
+    desugared.withSpan(tree.span)
   }
 
   /** Create a class definition with the same info as the refined type given by `parent`

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

@@ -59,24 +59,6 @@ abstract class Positioned(implicit @transientParam src: SourceFile) extends Prod
     newpd
   }
 
-  def withPosOf(posd: Positioned): this.type = {
-    val ownSpan = this.span
-    val newpd: this.type =
-      if ((posd.source `eq` source) && posd.span == ownSpan || ownSpan.isSynthetic) this
-      else cloneIn(posd.source)
-    newpd.setPos(posd.span, posd.source)
-    newpd
-  }
-
-  def withSourcePos(sourcePos: SourcePosition): this.type = {
-    val ownSpan = this.span
-    val newpd: this.type =
-      if ((sourcePos.source `eq` source) && sourcePos.span == ownSpan || ownSpan.isSynthetic) this
-      else cloneIn(sourcePos.source)
-    newpd.setPos(sourcePos.span, sourcePos.source)
-    newpd
-  }
-
   /** Set span of this tree only, without updating children spans.
    *  Called from Unpickler when entering positions.
    */

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

@@ -89,7 +89,7 @@ class TreeTypeMap(
     case tree1 =>
       tree1.withType(mapType(tree1.tpe)) match {
         case id: Ident if tpd.needsSelect(id.tpe) =>
-          ref(id.tpe.asInstanceOf[TermRef]).withPosOf(id)
+          ref(id.tpe.asInstanceOf[TermRef]).withSpan(id.span)
         case ddef @ DefDef(name, tparams, vparamss, tpt, _) =>
           val (tmap1, tparams1) = transformDefs(ddef.tparams)
           val (tmap2, vparamss1) = tmap1.transformVParamss(vparamss)
@@ -122,7 +122,7 @@ class TreeTypeMap(
           val expr1 = tmap.transform(expr)
           cpy.Labeled(labeled)(bind1, expr1)
         case Hole(n, args) =>
-          Hole(n, args.mapConserve(transform)).withPosOf(tree).withType(mapType(tree.tpe))
+          Hole(n, args.mapConserve(transform)).withSpan(tree.span).withType(mapType(tree.tpe))
         case tree1 =>
           super.transform(tree1)
       }

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

@@ -89,7 +89,7 @@ object Trees {
     /** Copy `tpe` attribute from tree `from` into this tree, independently
      *  whether it is null or not.
     final def copyAttr[U >: Untyped](from: Tree[U]): ThisTree[T] = {
-      val t1 = this.withPosOf(from)
+      val t1 = this.withSpan(from.span)
       val t2 =
         if (from.myTpe != null) t1.withType(from.myTpe.asInstanceOf[Type])
         else t1
@@ -807,10 +807,6 @@ object Trees {
 
     override def withSpan(span: Span): this.type =
       mapElems(_.withSpan(span)).asInstanceOf[this.type]
-    override def withPosOf(posd: Positioned): this.type =
-      mapElems(_.withPosOf(posd)).asInstanceOf[this.type]
-    override def withSourcePos(sourcePos: SourcePosition): this.type =
-      mapElems(_.withSourcePos(sourcePos)).asInstanceOf[this.type]
   }
 
   class EmptyTree[T >: Untyped] extends Thicket(Nil)(NoSource) {
@@ -978,10 +974,10 @@ object Trees {
       protected def postProcess(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[T]
 
       protected def finalize(tree: Tree, copied: untpd.Tree): copied.ThisTree[T] =
-        postProcess(tree, copied.withPosOf(tree).withAttachmentsFrom(tree))
+        postProcess(tree, copied.withSpan(tree.span).withAttachmentsFrom(tree))
 
       protected def finalize(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[T] =
-        postProcess(tree, copied.withPosOf(tree).withAttachmentsFrom(tree))
+        postProcess(tree, copied.withSpan(tree.span).withAttachmentsFrom(tree))
 
       protected def srcCtx(tree: Tree)(implicit ctx: Context) = ctx.withSource(tree.source)
 

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

@@ -1012,7 +1012,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       tree
     else {
       ctx.warning(i"conversion from ${tree.tpe.widen} to ${numericCls.typeRef} will always fail at runtime.")
-      Throw(New(defn.ClassCastExceptionClass.typeRef, Nil)).withPosOf(tree)
+      Throw(New(defn.ClassCastExceptionClass.typeRef, Nil)).withSpan(tree.span)
     }
   }
 
@@ -1201,7 +1201,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       // Give a zero-extent position to the qualifier to prevent it from being included several
       // times in results in the language server.
       val noPosExpr = focusPositions(imp.expr)
-      val selectTree = Select(noPosExpr, sym.name).withPosOf(id)
+      val selectTree = Select(noPosExpr, sym.name).withSpan(id.span)
       rename match {
         case None =>
           selectTree :: Nil
@@ -1210,7 +1210,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
           // node with the new name and the type of the real symbol.
           val name = if (sym.name.isTypeName) rename.name.toTypeName else rename.name
           val actual = Select(noPosExpr, sym.name)
-          val renameTree = Select(noPosExpr, name).withPosOf(rename).withType(actual.tpe)
+          val renameTree = Select(noPosExpr, name).withSpan(rename.span).withType(actual.tpe)
           selectTree :: renameTree :: Nil
       }
     }

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

@@ -325,7 +325,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         (tycon, targs)
       case TypedSplice(tpt1: tpd.Tree) =>
         val argTypes = tpt1.tpe.dealias.argTypesLo
-        def wrap(tpe: Type) = TypeTree(tpe).withPosOf(tpt)
+        def wrap(tpe: Type) = TypeTree(tpe).withSpan(tpt.span)
         (tpt, argTypes.map(wrap))
       case _ =>
         (tpt, Nil)

compiler/src/dotty/tools/dotc/core/quoted/PickledQuotes.scala

@@ -140,7 +140,7 @@ object PickledQuotes {
         new TreeTypeMap(
           oldOwners = ddef.symbol :: Nil,
           newOwners = ctx.owner :: Nil,
-          treeMap = tree => paramToVals.get(tree.symbol).map(_.withPosOf(tree)).getOrElse(tree)
+          treeMap = tree => paramToVals.get(tree.symbol).map(_.withSpan(tree.span)).getOrElse(tree)
         ).transform(ddef.rhs)
       case Block(stats, expr) =>
         seq(stats, rec(expr))

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -1031,7 +1031,7 @@ class TreeUnpickler(reader: TastyReader,
 
       def readQualId(): (untpd.Ident, TypeRef) = {
         val qual = readTerm().asInstanceOf[untpd.Ident]
-         (untpd.Ident(qual.name).withPosOf(qual), qual.tpe.asInstanceOf[TypeRef])
+         (untpd.Ident(qual.name).withSpan(qual.span), qual.tpe.asInstanceOf[TypeRef])
       }
 
       def accessibleDenot(pre: Type, name: Name, sig: Signature) = {

compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala

@@ -225,7 +225,7 @@ object JavaParsers {
     /** Convert (qual)ident to type identifier
       */
     def convertToTypeId(tree: Tree): Tree = convertToTypeName(tree) match {
-      case Some(t)  => t.withPosOf(tree)
+      case Some(t)  => t.withSpan(tree.span)
       case _        => tree match {
         case AppliedTypeTree(_, _) | Select(_, _) =>
           tree

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -367,9 +367,9 @@ object Parsers {
     */
     def convertToParam(tree: Tree, mods: Modifiers = Modifiers(), expected: String = "formal parameter"): ValDef = tree match {
       case Ident(name) =>
-        makeParameter(name.asTermName, TypeTree(), mods).withPosOf(tree)
+        makeParameter(name.asTermName, TypeTree(), mods).withSpan(tree.span)
       case Typed(Ident(name), tpt) =>
-        makeParameter(name.asTermName, tpt, mods).withPosOf(tree)
+        makeParameter(name.asTermName, tpt, mods).withSpan(tree.span)
       case _ =>
         syntaxError(s"not a legal $expected", tree.span)
         makeParameter(nme.ERROR, tree, mods)
@@ -2590,11 +2590,11 @@ object Parsers {
         if (in.token == ARROW) {
           first match {
             case Typed(tree @ This(EmptyTypeIdent), tpt) =>
-              self = makeSelfDef(nme.WILDCARD, tpt).withPosOf(first)
+              self = makeSelfDef(nme.WILDCARD, tpt).withSpan(first.span)
             case _ =>
               val ValDef(name, tpt, _) = convertToParam(first, EmptyModifiers, "self type clause")
               if (name != nme.ERROR)
-                self = makeSelfDef(name, tpt).withPosOf(first)
+                self = makeSelfDef(name, tpt).withSpan(first.span)
           }
           in.nextToken()
         } else {

compiler/src/dotty/tools/dotc/parsing/TreeBuilder.scala.unused

@@ -42,7 +42,7 @@ class TreeBuilder(implicit ctx: Context) {
       case Ident(name) if isVarPattern(tree) && name != nme.WILDCARD =>
         Bind(
           name, Ident(nme.WILDCARD).withPos(tree.pos.focus)
-        ).withPosOf(tree)
+        ).withSpan(tree.span)
       case Typed(id @ Ident(name), tpt) if isVarPattern(id) && name != nme.WILDCARD =>
         Bind(
           name,

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

@@ -407,7 +407,7 @@ trait TypeOrBoundsTreesOpsImpl extends scala.tasty.reflect.TypeOrBoundsTreeOps w
         // TODO only enums generate this kind of type bounds. Is this possible without enums? If not generate tpd.TypeBoundsTree for enums instead
         x.tpe match {
           case tpe: Types.TypeBounds =>
-            Some(tpd.TypeBoundsTree(tpd.TypeTree(tpe.lo).withPosOf(x), tpd.TypeTree(tpe.hi).withPosOf(x)))
+            Some(tpd.TypeBoundsTree(tpd.TypeTree(tpe.lo).withSpan(x.span), tpd.TypeTree(tpe.hi).withSpan(x.span)))
           case _ => None
         }
       case _ => None

compiler/src/dotty/tools/dotc/transform/AccessProxies.scala

@@ -97,7 +97,7 @@ abstract class AccessProxies {
         case Select(qual, _) if qual.tpe.derivesFrom(accessor.owner) => qual.select(accessor)
         case _ => ref(accessor)
       }
-    }.withPosOf(reference)
+    }.withSpan(reference.span)
 
     /** Given a reference to a getter accessor, the corresponding setter reference */
     def useSetter(getterRef: Tree)(implicit ctx: Context): Tree = getterRef match {

compiler/src/dotty/tools/dotc/transform/ByNameClosures.scala

@@ -28,7 +28,7 @@ class ByNameClosures extends TransformByNameApply with IdentityDenotTransformer
   override def mkByNameClosure(arg: Tree, argType: Type)(implicit ctx: Context): Tree = {
     val meth = ctx.newSymbol(
       ctx.owner, nme.ANON_FUN, Synthetic | Method, MethodType(Nil, Nil, argType))
-    Closure(meth, _ => arg.changeOwnerAfter(ctx.owner, meth, thisPhase)).withPosOf(arg)
+    Closure(meth, _ => arg.changeOwnerAfter(ctx.owner, meth, thisPhase)).withSpan(arg.span)
   }
 }
 

compiler/src/dotty/tools/dotc/transform/CapturedVars.scala

@@ -107,7 +107,7 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
         ref(vble.info.classSymbol.companionModule.info.member(name).symbol)
       cpy.ValDef(vdef)(
         rhs = boxMethod(nme.create).appliedTo(vdef.rhs),
-        tpt = TypeTree(vble.info).withPosOf(vdef.tpt))
+        tpt = TypeTree(vble.info).withSpan(vdef.tpt.span))
     } else vdef
   }
 

compiler/src/dotty/tools/dotc/transform/ClassOf.scala

@@ -21,7 +21,7 @@ class ClassOf extends MiniPhase {
   override def transformTypeApply(tree: TypeApply)(implicit ctx: Context): Tree =
     if (tree.symbol eq defn.Predef_classOf) {
       val targ = tree.args.head.tpe
-      clsOf(targ).ensureConforms(tree.tpe).withPosOf(tree)
+      clsOf(targ).ensureConforms(tree.tpe).withSpan(tree.span)
     }
     else tree
 }

compiler/src/dotty/tools/dotc/transform/Constructors.scala

@@ -149,7 +149,7 @@ class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase =
         case Ident(_) | Select(This(_), _) =>
           var sym = tree.symbol
           if (sym is (ParamAccessor, butNot = Mutable)) sym = sym.subst(accessors, paramSyms)
-          if (sym.owner.isConstructor) ref(sym).withPosOf(tree) else tree
+          if (sym.owner.isConstructor) ref(sym).withSpan(tree.span) else tree
         case Apply(fn, Nil) =>
           val fn1 = transform(fn)
           if ((fn1 ne fn) && fn1.symbol.is(Param) && fn1.symbol.owner.isPrimaryConstructor)
@@ -195,7 +195,7 @@ class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase =
             val sym = stat.symbol
             if (isRetained(sym)) {
               if (!stat.rhs.isEmpty && !isWildcardArg(stat.rhs))
-                constrStats += Assign(ref(sym), intoConstr(stat.rhs, sym)).withPosOf(stat)
+                constrStats += Assign(ref(sym), intoConstr(stat.rhs, sym)).withSpan(stat.span)
               clsStats += cpy.ValDef(stat)(rhs = EmptyTree)
             }
             else if (!stat.rhs.isEmpty) {
@@ -230,7 +230,7 @@ class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase =
         if (!target.exists) Nil // this case arises when the parameter accessor is an alias
         else {
           val param = acc.subst(accessors, paramSyms)
-          val assigns = Assign(ref(target), ref(param)).withPosOf(tree) :: Nil
+          val assigns = Assign(ref(target), ref(param)).withSpan(tree.span) :: Nil
           if (acc.name != nme.OUTER) assigns
           else {
             // insert test: if ($outer eq null) throw new NullPointerException

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -180,7 +180,7 @@ object Erasure {
     }
 
     def constant(tree: Tree, const: Tree)(implicit ctx: Context): Tree =
-      (if (isPureExpr(tree)) const else Block(tree :: Nil, const)).withPosOf(tree)
+      (if (isPureExpr(tree)) const else Block(tree :: Nil, const)).withSpan(tree.span)
 
     final def box(tree: Tree, target: => String = "")(implicit ctx: Context): Tree = trace(i"boxing ${tree.showSummary}: ${tree.tpe} into $target") {
       tree.tpe.widen match {
@@ -558,7 +558,7 @@ object Erasure {
       if (sym.isEffectivelyErased) erasedDef(sym)
       else
         super.typedValDef(untpd.cpy.ValDef(vdef)(
-          tpt = untpd.TypedSplice(TypeTree(sym.info).withPosOf(vdef.tpt))), sym)
+          tpt = untpd.TypedSplice(TypeTree(sym.info).withSpan(vdef.tpt.span))), sym)
 
     /** Besides normal typing, this function also compacts anonymous functions
      *  with more than `MaxImplementedFunctionArity` parameters to use a single
@@ -591,7 +591,7 @@ object Erasure {
         val ddef1 = untpd.cpy.DefDef(ddef)(
           tparams = Nil,
           vparamss = vparamss1,
-          tpt = untpd.TypedSplice(TypeTree(restpe).withPosOf(ddef.tpt)),
+          tpt = untpd.TypedSplice(TypeTree(restpe).withSpan(ddef.tpt.span)),
           rhs = rhs1)
         super.typedDefDef(ddef1, sym)
       }

compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala

@@ -105,7 +105,7 @@ class ExplicitOuter extends MiniPhase with InfoTransformer { thisPhase =>
             parent
           }
           else parent match { // ensure class parent is a constructor
-            case parent: TypeTree => New(parent.tpe, Nil).withPosOf(impl)
+            case parent: TypeTree => New(parent.tpe, Nil).withSpan(impl.span)
             case _ => parent
           }
         }
@@ -359,7 +359,7 @@ object ExplicitOuter {
         }
         if (hasOuterParam(cls))
           methPart(fun) match {
-            case Select(receiver, _) => outerArg(receiver).withPosOf(fun) :: Nil
+            case Select(receiver, _) => outerArg(receiver).withSpan(fun.span) :: Nil
           }
         else Nil
       } else Nil

compiler/src/dotty/tools/dotc/transform/ExplicitSelf.scala

@@ -29,7 +29,7 @@ class ExplicitSelf extends MiniPhase {
   override def transformIdent(tree: Ident)(implicit ctx: Context): Tree = tree.tpe match {
     case tp: ThisType =>
       ctx.debuglog(s"owner = ${ctx.owner}, context = ${ctx}")
-      This(tp.cls).withPosOf(tree)
+      This(tp.cls).withSpan(tree.span)
     case _ => tree
   }
 

compiler/src/dotty/tools/dotc/transform/FirstTransform.scala

@@ -107,7 +107,7 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
     if (meth.hasAnnotation(defn.NativeAnnot)) {
       meth.resetFlag(Deferred)
       polyDefDef(meth,
-        _ => _ => ref(defn.Sys_errorR).withPosOf(ddef)
+        _ => _ => ref(defn.Sys_errorR).withSpan(ddef.span)
           .appliedTo(Literal(Constant(s"native method stub"))))
 
     }
@@ -133,7 +133,7 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
    */
   private def toTypeTree(tree: Tree)(implicit ctx: Context) = {
     val binders = collectBinders.apply(Nil, tree)
-    val result: Tree = TypeTree(tree.tpe).withPosOf(tree)
+    val result: Tree = TypeTree(tree.tpe).withSpan(tree.span)
     (result /: binders)(Annotated(_, _))
   }
 

compiler/src/dotty/tools/dotc/transform/FullParameterization.scala

@@ -240,7 +240,7 @@ trait FullParameterization {
             ref(vparam.symbol).ensureConforms(paramType)
           }))
       })
-    }).withPosOf(originalDef.rhs)
+    }).withSpan(originalDef.rhs.span)
   }
 }