withPos -> 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).withPos(tdef.rhs.pos).watching(tdef)
+      rhs = new DerivedFromParamTree(suffix).withPosOf(tdef.rhs).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("").withPos(vdef.tpt.pos).watching(vdef))
+      tpt = new DerivedFromParamTree("").withPosOf(vdef.tpt).watching(vdef))
 
 // ----- Desugar methods -------------------------------------------------
 
@@ -351,10 +351,10 @@ object desugar {
     val constrVparamss =
       if (originalVparamss.isEmpty) { // ensure parameter list is non-empty
         if (isCaseClass && originalTparams.isEmpty)
-          ctx.error(CaseClassMissingParamList(cdef), cdef.sourcePos.withRange(cdef.namePos))
+          ctx.error(CaseClassMissingParamList(cdef), cdef.sourcePos.withSpan(cdef.namePos))
         ListOfNil
       } else if (isCaseClass && originalVparamss.head.exists(_.mods.is(Implicit))) {
-          ctx.error("Case classes should have a non-implicit parameter list", cdef.sourcePos.withRange(cdef.namePos))
+          ctx.error("Case classes should have a non-implicit parameter list", cdef.sourcePos.withSpan(cdef.namePos))
         ListOfNil
       }
       else originalVparamss.nestedMap(toDefParam)
@@ -398,7 +398,7 @@ object desugar {
 
     def appliedTypeTree(tycon: Tree, args: List[Tree]) =
       (if (args.isEmpty) tycon else AppliedTypeTree(tycon, args))
-        .withPos(cdef.pos.startPos)
+        .withSpan(cdef.pos.startPos)
 
     def isHK(tparam: Tree): Boolean = tparam match {
       case TypeDef(_, LambdaTypeTree(tparams, body)) => true
@@ -564,7 +564,7 @@ object desugar {
         ModuleDef(
           className.toTermName, Template(emptyConstructor, parentTpt :: Nil, EmptyValDef, defs))
             .withMods(companionMods | Synthetic))
-      .withPos(cdef.pos).toList
+      .withPosOf(cdef).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)
-          .withPos(cdef.pos) :: Nil
+          .withPosOf(cdef) :: Nil
 
     val self1 = {
       val selfType = if (self.tpt.isEmpty) classTypeRef else self.tpt
@@ -710,17 +710,17 @@ object desugar {
       val clsRef = Ident(clsName)
       val modul = ValDef(moduleName, clsRef, New(clsRef, Nil))
         .withMods(mods.toTermFlags & RetainedModuleValFlags | ModuleValCreationFlags)
-        .withPos(mdef.pos.startPos)
+        .withSpan(mdef.pos.startPos)
       val ValDef(selfName, selfTpt, _) = impl.self
       val selfMods = impl.self.mods
       if (!selfTpt.isEmpty) ctx.error(ObjectMayNotHaveSelfType(mdef), impl.self.sourcePos)
       val clsSelf = ValDef(selfName, SingletonTypeTree(Ident(moduleName)), impl.self.rhs)
         .withMods(selfMods)
-        .withPos(impl.self.pos orElse impl.pos.startPos)
+        .withSpan(impl.self.pos.orElse(impl.pos.startPos))
       val clsTmpl = cpy.Template(impl)(self = clsSelf, body = impl.body)
       val cls = TypeDef(clsName, clsTmpl)
         .withMods(mods.toTypeFlags & RetainedModuleClassFlags | ModuleClassCreationFlags)
-      Thicket(modul, classDef(cls).withPos(mdef.pos))
+      Thicket(modul, classDef(cls).withPosOf(mdef))
     }
   }
 
@@ -842,7 +842,7 @@ object desugar {
             mods & Lazy | Synthetic | (if (ctx.owner.isClass) PrivateLocal else EmptyFlags)
           val firstDef =
             ValDef(tmpName, TypeTree(), matchExpr)
-              .withPos(pat.pos.union(rhs.pos)).withMods(patMods)
+              .withSpan(pat.pos.union(rhs.pos)).withMods(patMods)
           def selector(n: Int) = Select(Ident(tmpName), nme.selectorName(n))
           val restDefs =
             for (((named, tpt), n) <- vars.zipWithIndex)
@@ -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)).withPos(tree.pos)
+    Bind(name, Ident(nme.WILDCARD)).withPosOf(tree)
   }
 
   def defTree(tree: Tree)(implicit ctx: Context): Tree = tree match {
@@ -879,7 +879,7 @@ object desugar {
   def block(tree: Block)(implicit ctx: Context): Block = tree.expr match {
     case EmptyTree =>
       cpy.Block(tree)(tree.stats,
-        unitLiteral withPos (if (tree.stats.isEmpty) tree.pos else tree.pos.endPos))
+        unitLiteral.withSpan(if (tree.stats.isEmpty) tree.pos else tree.pos.endPos))
     case _ =>
       tree
   }
@@ -900,7 +900,7 @@ object desugar {
         case Tuple(args) => args.mapConserve(assignToNamedArg)
         case _ => arg :: Nil
       }
-      Apply(Select(fn, op.name).withPos(selectPos), args)
+      Apply(Select(fn, op.name).withSpan(selectPos), args)
     }
 
     if (isLeftAssoc(op.name))
@@ -984,7 +984,7 @@ object desugar {
     val vdefs =
       params.zipWithIndex.map{
         case (param, idx) =>
-          DefDef(param.name, Nil, Nil, TypeTree(), selector(idx)).withPos(param.pos)
+          DefDef(param.name, Nil, Nil, TypeTree(), selector(idx)).withPosOf(param)
       }
     Function(param :: Nil, Block(vdefs, body))
   }
@@ -1020,15 +1020,15 @@ object desugar {
   private def derivedValDef(original: Tree, named: NameTree, tpt: Tree, rhs: Tree, mods: Modifiers)(implicit ctx: Context) = {
     val vdef = ValDef(named.name.asTermName, tpt, rhs)
       .withMods(mods)
-      .withPos(original.pos.withPoint(named.pos.start))
+      .withSpan(original.pos.withPoint(named.pos.start))
     val mayNeedSetter = valDef(vdef)
     mayNeedSetter
    }
 
   private def derivedDefDef(original: Tree, named: NameTree, tpt: Tree, rhs: Tree, mods: Modifiers)(implicit src: SourceInfo) =
     DefDef(named.name.asTermName, Nil, Nil, tpt, rhs)
       .withMods(mods)
-      .withPos(original.pos.withPoint(named.pos.start))
+      .withSpan(original.pos.withPoint(named.pos.start))
 
   /** Main desugaring method */
   def apply(tree: Tree)(implicit ctx: Context): Tree = {
@@ -1278,7 +1278,7 @@ object desugar {
               finalizer)
         }
     }
-    desugared.withPos(tree.pos)
+    desugared.withPosOf(tree)
   }
 
   /** Create a class definition with the same info as the refined type given by `parent`

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

@@ -60,7 +60,7 @@ object DesugarEnums {
                      |type parameter $tparam $problem""", ctx.source.atPos(pos))
       }
     }
-    TypeTree(enumClass.typeRef.appliedTo(targs)).withPos(pos)
+    TypeTree(enumClass.typeRef.appliedTo(targs)).withSpan(pos)
   }
 
   /** A type tree referring to `enumClass` */
@@ -207,7 +207,7 @@ object DesugarEnums {
       val (tagMeth, scaffolding) = enumTagMeth(CaseKind.Object)
       val impl1 = cpy.Template(impl)(body = List(tagMeth, toStringMeth) ++ registerCall)
       val vdef = ValDef(name, TypeTree(), New(impl1)).withMods(mods | Final)
-      flatTree(scaffolding ::: vdef :: Nil).withPos(pos)
+      flatTree(scaffolding ::: vdef :: Nil).withSpan(pos)
     }
   }
 
@@ -223,6 +223,6 @@ object DesugarEnums {
       val (tag, scaffolding) = nextEnumTag(CaseKind.Simple)
       val creator = Apply(Ident(nme.DOLLAR_NEW), List(Literal(Constant(tag)), Literal(Constant(name.toString))))
       val vdef = ValDef(name, enumClassRef, creator).withMods(mods | Final)
-      flatTree(scaffolding ::: vdef :: Nil).withPos(pos)
+      flatTree(scaffolding ::: vdef :: Nil).withSpan(pos)
     }
 }

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

@@ -35,7 +35,10 @@ abstract class Positioned(implicit @transientParam src: SourceInfo) extends Prod
   setId(TreeIds.nextIdFor(initialFile(src)))
   setPos(initialPos, srcfile)
 
-  protected def setId(id: Int): Unit = myUniqueId = id
+  protected def setId(id: Int): Unit = {
+    myUniqueId = id
+    //assert(id != 2067, getClass)
+  }
 
   /** Destructively update `curPos` to given position. Also, set any missing
    *  positions in children.
@@ -50,37 +53,32 @@ abstract class Positioned(implicit @transientParam src: SourceInfo) extends Prod
    *  If the positioned item is synthetic, the position is updated
    *  destructively and the item itself is returned.
    */
-  def withPos(pos: Position)(implicit src: SourceInfo): this.type = {
+  def withSpan(pos: Position): this.type = {
     val ownPos = this.pos
     val newpd: this.type =
       if (pos == ownPos || ownPos.isSynthetic) this else cloneIn(srcfile)
     newpd.setPos(pos, srcfile)
     newpd
   }
 
-  def withPosOf(posd: Positioned)(implicit ctx: Context): this.type = {
+  def withPosOf(posd: Positioned): this.type = {
     val ownPos = this.pos
     val newpd: this.type =
-      if (posd.source == source && posd.pos == ownPos || ownPos.isSynthetic) this
+      if (posd.srcfile == srcfile && posd.pos == ownPos || ownPos.isSynthetic) this
       else cloneIn(posd.srcfile)
     newpd.setPos(posd.pos, posd.srcfile)
     newpd
   }
 
-  def withSourcePos(sourcePos: SourcePosition)(implicit ctx: Context): this.type = {
+  def withSourcePos(sourcePos: SourcePosition): this.type = {
     val ownPos = this.pos
     val newpd: this.type =
-      if (sourcePos.source == source && sourcePos.pos == ownPos || ownPos.isSynthetic) this
+      if (sourcePos.source.file == srcfile && sourcePos.pos == ownPos || ownPos.isSynthetic) this
       else cloneIn(sourcePos.source.file)
     newpd.setPos(sourcePos.pos, sourcePos.source.file)
     newpd
   }
 
-  /** This item with a position that's the union of the given `pos` and the
-   *  current position.
-   */
-  def addPos(pos: Position)(implicit src: SourceInfo): this.type = withPos(pos union this.pos)
-
   /** Set position of this tree only, without performing
    *  any checks of consistency with - or updates of - other positions.
    *  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]).withPos(id.pos)
+          ref(id.tpe.asInstanceOf[TermRef]).withPosOf(id)
         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)).withPos(tree.pos).withType(mapType(tree.tpe))
+          Hole(n, args.mapConserve(transform)).withPosOf(tree).withType(mapType(tree.tpe))
         case tree1 =>
           super.transform(tree1)
       }

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

@@ -85,7 +85,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.withPos(from.pos)
+      val t1 = this.withPosOf(from)
       val t2 =
         if (from.myTpe != null) t1.withType(from.myTpe.asInstanceOf[Type])
         else t1
@@ -783,21 +783,30 @@ object Trees {
   case class Thicket[-T >: Untyped](trees: List[Tree[T]])(implicit @transientParam src: SourceInfo)
     extends Tree[T] with WithoutTypeOrPos[T] {
     myTpe = NoType.asInstanceOf[T]
-
     type ThisTree[-T >: Untyped] = Thicket[T]
-    override def isEmpty: Boolean = trees.isEmpty
-    override def toList: List[Tree[T]] = flatten(trees)
-    override def toString: String = if (isEmpty) "EmptyTree" else "Thicket(" + trees.mkString(", ") + ")"
-    override def withPos(pos: Position)(implicit src: SourceInfo): this.type = {
-      val newTrees = trees.mapConserve(_.withPos(pos))
+
+    def mapElems(op: Tree[T] => Tree[T] @uncheckedVariance): Thicket[T] = {
+      val newTrees = trees.mapConserve(op)
       if (trees eq newTrees)
         this
       else
         Thicket[T](newTrees).asInstanceOf[this.type]
     }
-    override def pos: Position = (NoPosition /: trees) ((pos, t) => pos union t.pos)
+
     override def foreachInThicket(op: Tree[T] => Unit): Unit =
       trees foreach (_.foreachInThicket(op))
+
+    override def isEmpty: Boolean = trees.isEmpty
+    override def toList: List[Tree[T]] = flatten(trees)
+    override def toString: String = if (isEmpty) "EmptyTree" else "Thicket(" + trees.mkString(", ") + ")"
+    override def pos: Position = (NoPosition /: trees) ((pos, t) => pos union t.pos)
+
+    override def withSpan(pos: Position): this.type =
+      mapElems(_.withSpan(pos)).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)(NoContext) {
@@ -965,10 +974,10 @@ object Trees {
       protected def postProcess(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[T]
 
       protected def finalize(tree: Tree, copied: untpd.Tree)(implicit src: SourceInfo): copied.ThisTree[T] =
-        postProcess(tree, copied.withPos(tree.pos).withAttachmentsFrom(tree))
+        postProcess(tree, copied.withPosOf(tree).withAttachmentsFrom(tree))
 
       protected def finalize(tree: Tree, copied: untpd.MemberDef)(implicit src: SourceInfo): copied.ThisTree[T] =
-        postProcess(tree, copied.withPos(tree.pos).withAttachmentsFrom(tree))
+        postProcess(tree, copied.withPosOf(tree).withAttachmentsFrom(tree))
 
       protected def srcCtx(tree: Tree)(implicit ctx: Context) = ctx.withSource(tree.source)
 

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

@@ -404,13 +404,13 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def newArray(elemTpe: Type, returnTpe: Type, pos: Position, dims: JavaSeqLiteral)(implicit ctx: Context): Tree = {
     val elemClass = elemTpe.classSymbol
     def newArr =
-      ref(defn.DottyArraysModule).select(defn.newArrayMethod).withPos(pos)
+      ref(defn.DottyArraysModule).select(defn.newArrayMethod).withSpan(pos)
 
     if (!ctx.erasedTypes) {
       assert(!TypeErasure.isGeneric(elemTpe)) //needs to be done during typer. See Applications.convertNewGenericArray
-      newArr.appliedToTypeTrees(TypeTree(returnTpe) :: Nil).appliedToArgs(clsOf(elemTpe) :: clsOf(returnTpe) :: dims :: Nil).withPos(pos)
+      newArr.appliedToTypeTrees(TypeTree(returnTpe) :: Nil).appliedToArgs(clsOf(elemTpe) :: clsOf(returnTpe) :: dims :: Nil).withSpan(pos)
     } else  // after erasure
-      newArr.appliedToArgs(clsOf(elemTpe) :: clsOf(returnTpe) :: dims :: Nil).withPos(pos)
+      newArr.appliedToArgs(clsOf(elemTpe) :: clsOf(returnTpe) :: dims :: Nil).withSpan(pos)
   }
 
   /** The wrapped array method name for an array of type elemtp */
@@ -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)) withPos tree.pos
+      Throw(New(defn.ClassCastExceptionClass.typeRef, Nil)).withPosOf(tree)
     }
   }
 
@@ -1204,7 +1204,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).withPos(id.pos)
+      val selectTree = Select(noPosExpr, sym.name).withPosOf(id)
       rename match {
         case None =>
           selectTree :: Nil
@@ -1213,7 +1213,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).withPos(rename.pos).withType(actual.tpe)
+          val renameTree = Select(noPosExpr, name).withPosOf(rename).withType(actual.tpe)
           selectTree :: renameTree :: Nil
       }
     }
@@ -1236,7 +1236,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   private def focusPositions(tree: Tree)(implicit ctx: Context): Tree = {
     val transformer = new tpd.TreeMap {
       override def transform(tree: Tree)(implicit ctx: Context): Tree = {
-        super.transform(tree).withPos(tree.pos.focus)
+        super.transform(tree).withSpan(tree.pos.focus)
       }
     }
     transformer.transform(tree)

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).withPos(tpt.pos)
+        def wrap(tpe: Type) = TypeTree(tpe).withPosOf(tpt)
         (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(_.withPos(tree.pos)).getOrElse(tree)
+          treeMap = tree => paramToVals.get(tree.symbol).map(_.withPosOf(tree)).getOrElse(tree)
         ).transform(ddef.rhs)
       case Block(stats, expr) =>
         seq(stats, rec(expr))

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

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