Rename SourcePos#pos -> SourcePos#span

Also: Better toText for source positions

 - only print file name instead of full path
 - enclose in <...> when printing in trees

Author: odersky

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -800,7 +800,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
 
 
     def freshLocal(cunit: CompilationUnit, name: String, tpe: Type, pos: Position, flags: Flags): Symbol = {
-      ctx.newSymbol(sym, name.toTermName, termFlagSet(flags), tpe, NoSymbol, pos.pos)
+      ctx.newSymbol(sym, name.toTermName, termFlagSet(flags), tpe, NoSymbol, pos.span)
     }
 
     def getter(clz: Symbol): Symbol = decorateSymbol(sym).getter

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

@@ -73,9 +73,9 @@ abstract class Positioned(implicit @transientParam src: SourceInfo) extends Prod
   def withSourcePos(sourcePos: SourcePosition): this.type = {
     val ownPos = this.pos
     val newpd: this.type =
-      if (sourcePos.source.file == srcfile && sourcePos.pos == ownPos || ownPos.isSynthetic) this
+      if (sourcePos.source.file == srcfile && sourcePos.span == ownPos || ownPos.isSynthetic) this
       else cloneIn(sourcePos.source.file)
-    newpd.setPos(sourcePos.pos, sourcePos.source.file)
+    newpd.setPos(sourcePos.span, sourcePos.source.file)
     newpd
   }
 

compiler/src/dotty/tools/dotc/interactive/Completion.scala

@@ -40,7 +40,7 @@ object Completion {
    *  @return offset and list of symbols for possible completions
    */
   def completions(pos: SourcePosition)(implicit ctx: Context): (Int, List[Completion]) = {
-    val path = Interactive.pathTo(ctx.compilationUnit.tpdTree, pos.pos)
+    val path = Interactive.pathTo(ctx.compilationUnit.tpdTree, pos.span)
     computeCompletions(pos, path)(Interactive.contextOfPath(path))
   }
 
@@ -62,7 +62,7 @@ object Completion {
         else Mode.None
 
       case Thicket(name :: _ :: Nil) :: (_: Import) :: _ =>
-        if (name.pos.contains(pos.pos)) Mode.Import
+        if (name.pos.contains(pos.span)) Mode.Import
         else Mode.None // Can't help completing the renaming
 
       case Import(_, _) :: _ =>
@@ -83,13 +83,13 @@ object Completion {
         completionPrefix(name :: Nil, pos)
 
       case Import(expr, selectors) :: _ =>
-        selectors.find(_.pos.contains(pos.pos)).map { selector =>
+        selectors.find(_.pos.contains(pos.span)).map { selector =>
           completionPrefix(selector.asInstanceOf[Tree] :: Nil, pos)
         }.getOrElse("")
 
       case (ref: RefTree) :: _ =>
         if (ref.name == nme.ERROR) ""
-        else ref.name.toString.take(pos.pos.point - ref.pos.point)
+        else ref.name.toString.take(pos.span.point - ref.pos.point)
 
       case _ =>
         ""
@@ -309,7 +309,7 @@ object Completion {
      */
     private def implicitConversionTargets(qual: Tree)(implicit ctx: Context): Set[Type] = {
       val typer = ctx.typer
-      val conversions = new typer.ImplicitSearch(defn.AnyType, qual, pos.pos).allImplicits
+      val conversions = new typer.ImplicitSearch(defn.AnyType, qual, pos.span).allImplicits
       val targets = conversions.map(_.widen.finalResultType)
       interactiv.println(i"implicit conversion targets considered: ${targets.toList}%, %")
       targets

compiler/src/dotty/tools/dotc/interactive/Interactive.scala

@@ -121,10 +121,10 @@ object Interactive {
         List(select.symbol)
 
       case (_: Thicket) :: (imp: Import) :: _ =>
-        importedSymbols(imp, _.pos.contains(pos.pos))
+        importedSymbols(imp, _.pos.contains(pos.span))
 
       case (imp: Import) :: _ =>
-        importedSymbols(imp, _.pos.contains(pos.pos))
+        importedSymbols(imp, _.pos.contains(pos.span))
 
       case _ =>
         List(enclosingTree(path).symbol)
@@ -252,7 +252,7 @@ object Interactive {
    */
   def pathTo(trees: List[SourceTree], pos: SourcePosition)(implicit ctx: Context): List[Tree] =
     trees.find(_.pos.contains(pos)) match {
-      case Some(tree) => pathTo(tree.tree, pos.pos)
+      case Some(tree) => pathTo(tree.tree, pos.span)
       case None => Nil
     }
 

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -505,10 +505,11 @@ class PlainPrinter(_ctx: Context) extends Printer {
     nodeName ~ "(" ~ elems ~ tpSuffix ~ ")" ~ (Str(tree.sourcePos.toString) provided ctx.settings.YprintPos.value)
   }.close // todo: override in refined printer
 
-  def toText(pos: SourcePosition): Text =
+  def toText(pos: SourcePosition): Text = {
     if (!pos.exists) "<no position>"
-    else if (pos.source.exists) s"${pos.source.file}:${pos.line + 1}"
-    else s"(no source file, offset = ${pos.pos.point})"
+    else if (pos.source.exists) s"${pos.source.file.name}:${pos.line + 1}"
+    else s"(no source file, offset = ${pos.span.point})"
+  }
 
   def toText(result: SearchResult): Text = result match {
     case result: SearchSuccess =>

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -600,9 +600,10 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       if (printPos) {
         val posStr =
           if (homogenizedView)
-            if (tree.isInstanceOf[MemberDef]) s"${tree.source}${tree.pos}"
-            else s"${tree.source}${tree.pos.toSynthetic}"
-          else tree.sourcePos.toString
+            if (tree.isInstanceOf[MemberDef]) Str(s"${tree.source}${tree.pos}")
+            else Str(s"${tree.source}${tree.pos.toSynthetic}")
+          else
+            "<" ~ toText(tree.sourcePos) ~ ">"
         val clsStr = ""//if (tree.isType) tree.getClass.toString else ""
         txt = (txt ~ "@" ~ posStr ~ clsStr).close
       }

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

@@ -86,7 +86,7 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
       owner = root,
       flags = (member.flags | Method | Bridge | Artifact) &~
         (Accessor | ParamAccessor | CaseAccessor | Deferred | Lazy | Module),
-      coord = bridgePosFor(member).pos).enteredAfter(thisPhase).asTerm
+      coord = bridgePosFor(member).span).enteredAfter(thisPhase).asTerm
 
     ctx.debuglog(
       i"""generating bridge from ${other.showLocated}: ${other.info}

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

@@ -265,7 +265,7 @@ class Staging extends MacroTransformWithImplicits {
           None
         } else {
           val reqType = defn.QuotedTypeType.appliedTo(tp)
-          val tag = ctx.typer.inferImplicitArg(reqType, pos.pos)
+          val tag = ctx.typer.inferImplicitArg(reqType, pos.span)
           tag.tpe match {
             case fail: SearchFailureType =>
               Some(i"""

compiler/src/dotty/tools/dotc/util/SourceFile.scala

@@ -77,7 +77,7 @@ class SourceFile(val file: AbstractFile, computeContent: => Array[Char]) extends
    *  For regular source files, simply return the argument.
    */
   def positionInUltimateSource(position: SourcePosition): SourcePosition =
-    SourcePosition(underlying, position.pos shift start)
+    SourcePosition(underlying, position.span shift start)
 
   private def isLineBreak(idx: Int) =
     if (idx >= length) false else {

compiler/src/dotty/tools/dotc/util/SourcePosition.scala

@@ -8,18 +8,18 @@ import Spans.{Span, NoSpan}
 import scala.annotation.internal.sharable
 
 /** A source position is comprised of a position in a source file */
-case class SourcePosition(source: SourceFile, pos: Span, outer: SourcePosition = NoSourcePosition)
+case class SourcePosition(source: SourceFile, span: Span, outer: SourcePosition = NoSourcePosition)
 extends interfaces.SourcePosition with Showable {
   /** Is `that` a source position contained in this source position ?
    *  `outer` is not taken into account. */
   def contains(that: SourcePosition): Boolean =
-    this.source == that.source && this.pos.contains(that.pos)
+    this.source == that.source && this.span.contains(that.span)
 
-  def exists: Boolean = pos.exists
+  def exists: Boolean = span.exists
 
   def lineContent: String = source.lineContent(point)
 
-  def point: Int = pos.point
+  def point: Int = span.point
 
   /** The line of the position, starting at 0 */
   def line: Int = source.offsetToLine(point)
@@ -45,25 +45,25 @@ extends interfaces.SourcePosition with Showable {
   /** The column of the position, starting at 0 */
   def column: Int = source.column(point)
 
-  def start: Int = pos.start
+  def start: Int = span.start
   def startLine: Int = source.offsetToLine(start)
   def startColumn: Int = source.column(start)
   def startColumnPadding: String = source.startColumnPadding(start)
 
-  def end: Int = pos.end
+  def end: Int = span.end
   def endLine: Int = source.offsetToLine(end)
   def endColumn: Int = source.column(end)
 
-  def withOuter(outer: SourcePosition): SourcePosition = SourcePosition(source, pos, outer)
+  def withOuter(outer: SourcePosition): SourcePosition = SourcePosition(source, span, outer)
   def withSpan(range: Span) = SourcePosition(source, range, outer)
 
-  def startPos: SourcePosition = withSpan(pos.startPos)
-  def endPos  : SourcePosition = withSpan(pos.endPos)
-  def focus   : SourcePosition = withSpan(pos.focus)
-  def toSynthetic: SourcePosition = withSpan(pos.toSynthetic)
+  def startPos: SourcePosition = withSpan(span.startPos)
+  def endPos  : SourcePosition = withSpan(span.endPos)
+  def focus   : SourcePosition = withSpan(span.focus)
+  def toSynthetic: SourcePosition = withSpan(span.toSynthetic)
 
   override def toString: String =
-    s"${if (source.exists) source.file.toString else "(no source)"}:$pos"
+    s"${if (source.exists) source.file.toString else "(no source)"}:$span"
 
   def toText(printer: Printer): Text = printer.toText(this)
 }