Position -> Span

Author: odersky

compiler/src/dotty/tools/backend/sjs/JSPositions.scala

@@ -2,16 +2,16 @@ package dotty.tools.backend.sjs
 
 import dotty.tools.dotc.core._
 import Contexts._
-import dotty.tools.dotc.util.Positions
-import Positions.Position
+import dotty.tools.dotc.util.Spans
+import Spans.Span
 
 import org.scalajs.ir
 
 /** Conversion utilities from dotty Positions to IR Positions. */
 class JSPositions()(implicit ctx: Context) {
 
   /** Implicit conversion from dotty Position to ir.Position. */
-  implicit def pos2irPos(pos: Position): ir.Position = {
+  implicit def pos2irPos(pos: Span): ir.Position = {
     if (!pos.exists) ir.Position.NoPosition
     else {
       val source = pos2irPosCache.toIRSource(ctx.compilationUnit.source)
@@ -23,7 +23,7 @@ class JSPositions()(implicit ctx: Context) {
 
   /** Implicitly materializes an ir.Position from an implicit dotty Position. */
   implicit def implicitPos2irPos(
-      implicit pos: Position): ir.Position = {
+      implicit pos: Span): ir.Position = {
     pos2irPos(pos)
   }
 

compiler/src/dotty/tools/dotc/ast/CheckTrees.scala.disabled

@@ -3,7 +3,7 @@ package dotc
 package ast
 
 import core._
-import util.Positions._, Types._, Contexts._, Constants._, Names._, Flags._
+import util.Spans._, Types._, Contexts._, Constants._, Names._, Flags._
 import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._
 
 // TODO: revise, integrate in a checking phase.

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

@@ -3,7 +3,7 @@ package dotc
 package ast
 
 import core._
-import util.Positions._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags._
+import util.Spans._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags._
 import Symbols._, StdNames._, Trees._
 import Decorators._, transform.SymUtils._
 import NameKinds.{UniqueName, EvidenceParamName, DefaultGetterName}
@@ -793,7 +793,7 @@ object desugar {
       pats map {
         case id: Ident =>
           expandSimpleEnumCase(id.name.asTermName, mods,
-            Position(pdef.pos.start, id.pos.end, id.pos.start))
+            Span(pdef.pos.start, id.pos.end, id.pos.start))
     }
     else {
       val pats1 = if (tpt.isEmpty) pats else pats map (Typed(_, tpt))
@@ -894,7 +894,7 @@ object desugar {
       case Assign(Ident(name), rhs) => cpy.NamedArg(arg)(name, rhs)
       case _ => arg
     }
-    def makeOp(fn: Tree, arg: Tree, selectPos: Position) = {
+    def makeOp(fn: Tree, arg: Tree, selectPos: Span) = {
       val args: List[Tree] = arg match {
         case Parens(arg) => assignToNamedArg(arg) :: Nil
         case Tuple(args) => args.mapConserve(assignToNamedArg)
@@ -904,9 +904,9 @@ object desugar {
     }
 
     if (isLeftAssoc(op.name))
-      makeOp(left, right, Position(left.pos.start, op.pos.end, op.pos.start))
+      makeOp(left, right, Span(left.pos.start, op.pos.end, op.pos.start))
     else
-      makeOp(right, left, Position(op.pos.start, right.pos.end))
+      makeOp(right, left, Span(op.pos.start, right.pos.end))
   }
 
   /** Translate tuple expressions of arity <= 22

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

@@ -3,7 +3,7 @@ package dotc
 package ast
 
 import core._
-import util.Positions._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags._
+import util.Spans._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags._
 import Symbols._, StdNames._, Trees._
 import Decorators._
 import util.Property
@@ -44,7 +44,7 @@ object DesugarEnums {
    *  It is an error if a type parameter is non-variant, or if its approximation
    *  refers to pther type parameters.
    */
-  def interpolatedEnumParent(pos: Position)(implicit ctx: Context): Tree = {
+  def interpolatedEnumParent(pos: Span)(implicit ctx: Context): Tree = {
     val tparams = enumClass.typeParams
     def isGround(tp: Type) = tp.subst(tparams, tparams.map(_ => NoType)) eq tp
     val targs = tparams map { tparam =>
@@ -195,7 +195,7 @@ object DesugarEnums {
   }
 
   /** Expand a module definition representing a parameterless enum case */
-  def expandEnumModule(name: TermName, impl: Template, mods: Modifiers, pos: Position)(implicit ctx: Context): Tree = {
+  def expandEnumModule(name: TermName, impl: Template, mods: Modifiers, pos: Span)(implicit ctx: Context): Tree = {
     assert(impl.body.isEmpty)
     if (!enumClass.exists) EmptyTree
     else if (impl.parents.isEmpty)
@@ -212,7 +212,7 @@ object DesugarEnums {
   }
 
   /** Expand a simple enum case */
-  def expandSimpleEnumCase(name: TermName, mods: Modifiers, pos: Position)(implicit ctx: Context): Tree =
+  def expandSimpleEnumCase(name: TermName, mods: Modifiers, pos: Span)(implicit ctx: Context): Tree =
     if (!enumClass.exists) EmptyTree
     else if (enumClass.typeParams.nonEmpty) {
       val parent = interpolatedEnumParent(pos)

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

@@ -3,7 +3,7 @@ package ast
 
 import core.Contexts.Context
 import core.Decorators._
-import util.Positions._
+import util.Spans._
 import Trees.{MemberDef, DefTree, WithLazyField}
 
 /** Utility functions to go from typed to untyped ASTs */
@@ -54,7 +54,7 @@ object NavigateAST {
   /** The reverse part of the untyped root of the compilation unit of `ctx` to
    *  position `pos`.
    */
-  def untypedPath(pos: Position)(implicit ctx: Context): List[Positioned] =
+  def untypedPath(pos: Span)(implicit ctx: Context): List[Positioned] =
     pathTo(pos, ctx.compilationUnit.untpdTree)
 
 
@@ -67,7 +67,7 @@ object NavigateAST {
    *                         end point are the same, so this is useful when trying to reconcile
    *                         nodes with source code.
    */
-  def pathTo(pos: Position, from: Positioned, skipZeroExtent: Boolean = false)(implicit ctx: Context): List[Positioned] = {
+  def pathTo(pos: Span, from: Positioned, skipZeroExtent: Boolean = false)(implicit ctx: Context): List[Positioned] = {
     def childPath(it: Iterator[Any], path: List[Positioned]): List[Positioned] = {
       while (it.hasNext) {
         val path1 = it.next() match {

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

@@ -2,7 +2,7 @@ package dotty.tools
 package dotc
 package ast
 
-import util.Positions._
+import util.Spans._
 import util.{SourceFile, SourcePosition}
 import core.Contexts.{Context, SourceInfo}
 import core.Decorators._
@@ -20,10 +20,10 @@ abstract class Positioned(implicit @transientParam src: SourceInfo) extends Prod
    *  component of the position.
    */
   private var myUniqueId: Int = _
-  private[this] var curPos: Position = _
+  private[this] var curPos: Span = _
 
   /** The item's position */
-  def pos: Position = curPos
+  def pos: Span = curPos
 
   /** item's id */
   def uniqueId: Int = myUniqueId
@@ -43,7 +43,7 @@ abstract class Positioned(implicit @transientParam src: SourceInfo) extends Prod
   /** Destructively update `curPos` to given position. Also, set any missing
    *  positions in children.
    */
-  protected def setPos(pos: Position, file: AbstractFile): Unit = {
+  protected def setPos(pos: Span, file: AbstractFile): Unit = {
     setPosUnchecked(pos, file)
     if (pos.exists) setChildPositions(pos.toSynthetic, file)
   }
@@ -53,7 +53,7 @@ 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 withSpan(pos: Position): this.type = {
+  def withSpan(pos: Span): this.type = {
     val ownPos = this.pos
     val newpd: this.type =
       if (pos == ownPos || ownPos.isSynthetic) this else cloneIn(srcfile)
@@ -83,7 +83,7 @@ abstract class Positioned(implicit @transientParam src: SourceInfo) extends Prod
    *  any checks of consistency with - or updates of - other positions.
    *  Called from Unpickler when entering positions.
    */
-  private[dotc] def setPosUnchecked(pos: Position, file: AbstractFile = this.srcfile): Unit = {
+  private[dotc] def setPosUnchecked(pos: Span, file: AbstractFile = this.srcfile): Unit = {
     if (file != this.srcfile) setId(TreeIds.nextIdFor(file))
     curPos = pos
   }
@@ -99,7 +99,7 @@ abstract class Positioned(implicit @transientParam src: SourceInfo) extends Prod
    *  But since mutual tail recursion is not supported in Scala, we express it instead
    *  as a while loop with a termination by return in the middle.
    */
-  private def setChildPositions(pos: Position, file: AbstractFile): Unit = {
+  private def setChildPositions(pos: Span, file: AbstractFile): Unit = {
     var n = productArity                    // subnodes are analyzed right to left
     var elems: List[Any] = Nil              // children in lists still to be considered, from right to left
     var end = pos.end                       // the last defined offset, fill in positions up to this offset
@@ -111,10 +111,10 @@ abstract class Positioned(implicit @transientParam src: SourceInfo) extends Prod
         // synthetic. We can preserve this invariant by always setting a
         // zero-extent position for these trees here.
         if (!p.pos.exists || p.pos.isZeroExtent) {
-          p.setPos(Position(start, start), file)
+          p.setPos(Span(start, start), file)
           fillIn(ps1, start, end)
         } else {
-          p.setPos(Position(start, end), file)
+          p.setPos(Span(start, end), file)
           fillIn(ps1, end, end)
         }
       case nil =>
@@ -186,22 +186,22 @@ abstract class Positioned(implicit @transientParam src: SourceInfo) extends Prod
    *                           needed for pickling, since TypeTrees are pickled as types, so
    *                           their position is lost.
    */
-  def initialSpan(ignoreTypeTrees: Boolean = false): Position = {
+  def initialSpan(ignoreTypeTrees: Boolean = false): Span = {
 
-    def include(p1: Position, p2: Positioned) = p2 match {
+    def include(p1: Span, p2: Positioned) = p2 match {
       case _: Trees.TypeTree[_] if ignoreTypeTrees => p1
       case _ => p1.union(p2.pos)
     }
 
-    def includeAll(pos: Position, xs: List[_]): Position = xs match {
+    def includeAll(pos: Span, xs: List[_]): Span = xs match {
       case (p: Positioned) :: xs1 if sameSource(p) => includeAll(include(pos, p), xs1)
       case (xs0: List[_]) :: xs1 => includeAll(includeAll(pos, xs0), xs1)
       case _ :: xs1 => includeAll(pos, xs1)
       case _ => pos
     }
 
     var n = productArity
-    var pos = NoPosition
+    var pos = NoSpan
     while (n > 0) {
       n -= 1
       productElement(n) match {
@@ -246,7 +246,7 @@ abstract class Positioned(implicit @transientParam src: SourceInfo) extends Prod
   def checkPos(nonOverlapping: Boolean)(implicit ctx: Context): Unit = try {
     import untpd._
     var lastPositioned: Positioned = null
-    var lastPos = NoPosition
+    var lastPos = NoSpan
     def check(p: Any): Unit = p match {
       case p: Positioned =>
         assert(pos contains p.pos,

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

@@ -3,7 +3,7 @@ package dotc
 package ast
 
 import core._
-import Types._, Names._, NameOps._, Flags._, util.Positions._, Contexts._, Constants._
+import Types._, Names._, NameOps._, Flags._, util.Spans._, Contexts._, Constants._
 import SymDenotations._, Symbols._, Denotations._, StdNames._, Comments._
 import language.higherKinds
 import collection.mutable.ListBuffer
@@ -339,13 +339,13 @@ object Trees {
      *  This is a point position if the definition is synthetic, or a range position
      *  if the definition comes from source.
      *  It might also be that the definition does not have a position (for instance when synthesized by
-     *  a calling chain from `viewExists`), in that case the return position is NoPosition.
+     *  a calling chain from `viewExists`), in that case the return position is NoSpan.
      */
-    def namePos: Position =
+    def namePos: Span =
       if (pos.exists) {
         val point = pos.point
-        if (rawMods.is(Synthetic) || name.toTermName == nme.ERROR) Position(point)
-        else Position(point, point + name.stripModuleClassSuffix.lastPart.length, point)
+        if (rawMods.is(Synthetic) || name.toTermName == nme.ERROR) Span(point)
+        else Span(point, point + name.stripModuleClassSuffix.lastPart.length, point)
       }
       else pos
   }
@@ -598,7 +598,7 @@ object Trees {
   case class Inlined[-T >: Untyped] private[ast] (call: tpd.Tree, bindings: List[MemberDef[T]], expansion: Tree[T])(implicit @transientParam src: SourceInfo)
     extends Tree[T] {
     type ThisTree[-T >: Untyped] = Inlined[T]
-    override def initialSpan(ignoreTypeTrees: Boolean): Position = call.pos
+    override def initialSpan(ignoreTypeTrees: Boolean): Span = call.pos
   }
 
   /** A type tree that represents an existing or inferred type */
@@ -771,8 +771,8 @@ object Trees {
 
   trait WithoutTypeOrPos[-T >: Untyped] extends Tree[T] {
     override def withTypeUnchecked(tpe: Type): ThisTree[Type] = this.asInstanceOf[ThisTree[Type]]
-    override def pos: Position = NoPosition
-    override def setPos(pos: Position, file: AbstractFile): Unit = {}
+    override def pos: Span = NoSpan
+    override def setPos(pos: Span, file: AbstractFile): Unit = {}
   }
 
   /** Temporary class that results from translation of ModuleDefs
@@ -799,9 +799,9 @@ object Trees {
     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 pos: Span = (NoSpan /: trees) ((pos, t) => pos union t.pos)
 
-    override def withSpan(pos: Position): this.type =
+    override def withSpan(pos: Span): this.type =
       mapElems(_.withSpan(pos)).asInstanceOf[this.type]
     override def withPosOf(posd: Positioned): this.type =
       mapElems(_.withPosOf(posd)).asInstanceOf[this.type]

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

@@ -7,7 +7,7 @@ import dotty.tools.dotc.typer.ProtoTypes.FunProtoTyped
 import transform.SymUtils._
 import transform.TypeUtils._
 import core._
-import util.Positions._, Types._, Contexts._, Constants._, Names._, Flags._, NameOps._
+import util.Spans._, Types._, Contexts._, Constants._, Names._, Flags._, NameOps._
 import Symbols._, StdNames._, Annotations._, Trees._, Symbols._
 import Decorators._, DenotTransformers._
 import collection.mutable
@@ -401,7 +401,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
    *  kind for the given element type in `elemTpe`. No type arguments or
    *  `length` arguments are given.
    */
-  def newArray(elemTpe: Type, returnTpe: Type, pos: Position, dims: JavaSeqLiteral)(implicit ctx: Context): Tree = {
+  def newArray(elemTpe: Type, returnTpe: Type, pos: Span, dims: JavaSeqLiteral)(implicit ctx: Context): Tree = {
     val elemClass = elemTpe.classSymbol
     def newArr =
       ref(defn.DottyArraysModule).select(defn.newArrayMethod).withSpan(pos)

compiler/src/dotty/tools/dotc/core/Comments.scala

@@ -5,7 +5,7 @@ package core
 import ast.{ untpd, tpd }
 import Decorators._, Symbols._, Contexts._
 import util.SourceFile
-import util.Positions._
+import util.Spans._
 import util.CommentParsing._
 import util.Property.Key
 import parsing.Parsers.Parser
@@ -45,7 +45,7 @@ object Comments {
    * @param expanded If this comment has been expanded, it's expansion, otherwise `None`.
    * @param usecases The usecases for this comment.
    */
-  final case class Comment(pos: Position, raw: String, expanded: Option[String], usecases: List[UseCase]) {
+  final case class Comment(pos: Span, raw: String, expanded: Option[String], usecases: List[UseCase]) {
 
     /** Has this comment been cooked or expanded? */
     def isExpanded: Boolean = expanded.isDefined
@@ -74,10 +74,10 @@ object Comments {
 
     def isDocComment(comment: String): Boolean = comment.startsWith("/**")
 
-    def apply(pos: Position, raw: String): Comment =
+    def apply(pos: Span, raw: String): Comment =
       Comment(pos, raw, None, Nil)
 
-    private def parseUsecases(expandedComment: String, pos: Position)(implicit ctx: Context): List[UseCase] =
+    private def parseUsecases(expandedComment: String, pos: Span)(implicit ctx: Context): List[UseCase] =
       if (!isDocComment(expandedComment)) {
         Nil
       } else {
@@ -94,9 +94,9 @@ object Comments {
      *  def foo: A = ???
      *  }}}
      */
-    private[this] def decomposeUseCase(body: String, pos: Position, start: Int, end: Int)(implicit ctx: Context): UseCase = {
+    private[this] def decomposeUseCase(body: String, pos: Span, start: Int, end: Int)(implicit ctx: Context): UseCase = {
       def subPos(start: Int, end: Int) =
-        if (pos == NoPosition) NoPosition
+        if (pos == NoSpan) NoSpan
         else {
           val start1 = pos.start + start
           val end1 = pos.end + end
@@ -112,12 +112,12 @@ object Comments {
     }
   }
 
-  final case class UseCase(code: String, codePos: Position, untpdCode: untpd.Tree, tpdCode: Option[tpd.DefDef]) {
+  final case class UseCase(code: String, codePos: Span, untpdCode: untpd.Tree, tpdCode: Option[tpd.DefDef]) {
     def typed(tpdCode: tpd.DefDef): UseCase = copy(tpdCode = Some(tpdCode))
   }
 
   object UseCase {
-    def apply(code: String, codePos: Position)(implicit ctx: Context): UseCase = {
+    def apply(code: String, codePos: Span)(implicit ctx: Context): UseCase = {
       val tree = {
         val tree = new Parser(new SourceFile("<usecase>", code)).localDef(codePos.start)
         tree match {
@@ -441,8 +441,8 @@ object Comments {
      *  If a symbol does not have a doc comment but some overridden version of it does,
      *  the position of the doc comment of the overridden version is returned instead.
      */
-    def docCommentPos(sym: Symbol)(implicit ctx: Context): Position =
-      ctx.docCtx.flatMap(_.docstring(sym).map(_.pos)).getOrElse(NoPosition)
+    def docCommentPos(sym: Symbol)(implicit ctx: Context): Span =
+      ctx.docCtx.flatMap(_.docstring(sym).map(_.pos)).getOrElse(NoSpan)
 
     /** A version which doesn't consider self types, as a temporary measure:
      *  an infinite loop has broken out between superComment and cookedDocComment