Rename Symbol#pos -> span, Comment#pos -> span

Author: odersky

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

@@ -129,7 +129,7 @@ class JSCodeGen()(implicit ctx: Context) {
     /* Finally, we emit true code for the remaining class defs. */
     for (td <- allTypeDefs) {
       val sym = td.symbol
-      implicit val pos: Position = sym.pos
+      implicit val pos: Position = sym.span
 
       /* Do not actually emit code for primitive types nor scala.Array. */
       val isPrimitive =
@@ -197,7 +197,7 @@ class JSCodeGen()(implicit ctx: Context) {
    */
   private def genScalaClass(td: TypeDef): js.ClassDef = {
     val sym = td.symbol.asClass
-    implicit val pos: Position = sym.pos
+    implicit val pos: Position = sym.span
 
     assert(!sym.is(Trait),
         "genScalaClass() must be called only for normal classes: "+sym)
@@ -321,7 +321,7 @@ class JSCodeGen()(implicit ctx: Context) {
    */
   private def genRawJSClassData(td: TypeDef): js.ClassDef = {
     val sym = td.symbol.asClass
-    implicit val pos: Position = sym.pos
+    implicit val pos: Position = sym.span
 
     val classIdent = encodeClassFullNameIdent(sym)
     val kind = {
@@ -357,7 +357,7 @@ class JSCodeGen()(implicit ctx: Context) {
    */
   private def genInterface(td: TypeDef): js.ClassDef = {
     val sym = td.symbol.asClass
-    implicit val pos: Position = sym.pos
+    implicit val pos: Position = sym.span
 
     val classIdent = encodeClassFullNameIdent(sym)
 
@@ -413,7 +413,7 @@ class JSCodeGen()(implicit ctx: Context) {
 
     // Non-method term members are fields
     classSym.info.decls.filter(f => !f.is(Method) && f.isTerm).map({ f =>
-      implicit val pos = f.pos
+      implicit val pos = f.span
 
       val name =
         /*if (isExposed(f)) js.StringLiteral(jsNameOf(f))
@@ -506,7 +506,7 @@ class JSCodeGen()(implicit ctx: Context) {
       val methodName: js.PropertyName = encodeMethodSym(sym)
 
       def jsParams = for (param <- params) yield {
-        implicit val pos = param.pos
+        implicit val pos = param.span
         js.ParamDef(encodeLocalSym(param), toIRType(param.info),
             mutable = false, rest = false)
       }
@@ -585,7 +585,7 @@ class JSCodeGen()(implicit ctx: Context) {
     ctx.debuglog("")
 
     val jsParams = for (param <- paramsSyms) yield {
-      implicit val pos = param.pos
+      implicit val pos = param.span
       js.ParamDef(encodeLocalSym(param), toIRType(param.info),
           mutable = false, rest = false)
     }

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

@@ -663,11 +663,11 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
    *  if no such path exists.
    *  Pre: `sym` must have a position.
    */
-  def defPath(sym: Symbol, root: Tree)(implicit ctx: Context): List[Tree] = trace.onDebug(s"defpath($sym with position ${sym.pos}, ${root.show})") {
-    require(sym.pos.exists)
+  def defPath(sym: Symbol, root: Tree)(implicit ctx: Context): List[Tree] = trace.onDebug(s"defpath($sym with position ${sym.span}, ${root.show})") {
+    require(sym.span.exists)
     object accum extends TreeAccumulator[List[Tree]] {
       def apply(x: List[Tree], tree: Tree)(implicit ctx: Context): List[Tree] = {
-        if (tree.span.contains(sym.pos))
+        if (tree.span.contains(sym.span))
           if (definedSym(tree) == sym) tree :: x
           else {
             val x1 = foldOver(x, tree)
@@ -716,7 +716,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
    *  tree must be reachable from come tree stored in an enclosing context.
    */
   def definingStats(sym: Symbol)(implicit ctx: Context): List[Tree] =
-    if (!sym.pos.exists || (ctx eq NoContext) || ctx.compilationUnit == null) Nil
+    if (!sym.span.exists || (ctx eq NoContext) || ctx.compilationUnit == null) Nil
     else defPath(sym, ctx.compilationUnit.tpdTree) match {
       case defn :: encl :: _ =>
         def verify(stats: List[Tree]) =

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

@@ -314,7 +314,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       if (parents.head.classSymbol.is(Trait)) parents.head.parents.head :: parents
       else parents
     val cls = ctx.newNormalizedClassSymbol(owner, tpnme.ANON_CLASS, Synthetic | Final, parents1,
-        coord = fns.map(_.pos).reduceLeft(_ union _))
+        coord = fns.map(_.span).reduceLeft(_ union _))
     val constr = ctx.newConstructor(cls, Synthetic, Nil, Nil).entered
     def forwarder(fn: TermSymbol, name: TermName) = {
       val fwdMeth = fn.copy(cls, name, Synthetic | Method | Final).entered.asTerm

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

@@ -40,12 +40,12 @@ object Comments {
    * A `Comment` contains the unformatted docstring, it's position and potentially more
    * information that is populated when the comment is "cooked".
    *
-   * @param pos      The position of this `Comment`.
+   * @param span     The position span of this `Comment`.
    * @param raw      The raw comment, as seen in the source code, without any expansion.
    * @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: Span, raw: String, expanded: Option[String], usecases: List[UseCase]) {
+  final case class Comment(span: Span, raw: String, expanded: Option[String], usecases: List[UseCase]) {
 
     /** Has this comment been cooked or expanded? */
     def isExpanded: Boolean = expanded.isDefined
@@ -65,25 +65,25 @@ object Comments {
      */
     def expand(f: String => String)(implicit ctx: Context): Comment = {
       val expandedComment = f(raw)
-      val useCases = Comment.parseUsecases(expandedComment, pos)
-      Comment(pos, raw, Some(expandedComment), useCases)
+      val useCases = Comment.parseUsecases(expandedComment, span)
+      Comment(span, raw, Some(expandedComment), useCases)
     }
   }
 
   object Comment {
 
     def isDocComment(comment: String): Boolean = comment.startsWith("/**")
 
-    def apply(pos: Span, raw: String): Comment =
-      Comment(pos, raw, None, Nil)
+    def apply(span: Span, raw: String): Comment =
+      Comment(span, raw, None, Nil)
 
-    private def parseUsecases(expandedComment: String, pos: Span)(implicit ctx: Context): List[UseCase] =
+    private def parseUsecases(expandedComment: String, span: Span)(implicit ctx: Context): List[UseCase] =
       if (!isDocComment(expandedComment)) {
         Nil
       } else {
         tagIndex(expandedComment)
           .filter { startsWithTag(expandedComment, _, "@usecase") }
-          .map { case (start, end) => decomposeUseCase(expandedComment, pos, start, end) }
+          .map { case (start, end) => decomposeUseCase(expandedComment, span, start, end) }
       }
 
     /** Turns a usecase section into a UseCase, with code changed to:
@@ -94,13 +94,13 @@ object Comments {
      *  def foo: A = ???
      *  }}}
      */
-    private[this] def decomposeUseCase(body: String, pos: Span, start: Int, end: Int)(implicit ctx: Context): UseCase = {
+    private[this] def decomposeUseCase(body: String, span: Span, start: Int, end: Int)(implicit ctx: Context): UseCase = {
       def subPos(start: Int, end: Int) =
-        if (pos == NoSpan) NoSpan
+        if (span == NoSpan) NoSpan
         else {
-          val start1 = pos.start + start
-          val end1 = pos.end + end
-          pos withStart start1 withPoint start1 withEnd end1
+          val start1 = span.start + start
+          val end1 = span.end + end
+          span withStart start1 withPoint start1 withEnd end1
         }
 
       val codeStart = skipWhitespace(body, start + "@usecase".length)
@@ -199,7 +199,7 @@ object Comments {
         case None =>
           // SI-8210 - The warning would be false negative when this symbol is a setter
           if (ownComment.indexOf("@inheritdoc") != -1 && ! sym.isSetter)
-            dottydoc.println(s"${sym.pos}: the comment for ${sym} contains @inheritdoc, but no parent comment is available to inherit from.")
+            dottydoc.println(s"${sym.span}: the comment for ${sym} contains @inheritdoc, but no parent comment is available to inherit from.")
           ownComment.replaceAllLiterally("@inheritdoc", "<invalid inheritdoc annotation>")
         case Some(sc) =>
           if (ownComment == "") sc
@@ -314,7 +314,7 @@ object Comments {
                 val sectionTextBounds = extractSectionText(parent, section)
                 cleanupSectionText(parent.substring(sectionTextBounds._1, sectionTextBounds._2))
               case None =>
-                dottydoc.println(s"""${sym.pos}: the """" + getSectionHeader + "\" annotation of the " + sym +
+                dottydoc.println(s"""${sym.span}: the """" + getSectionHeader + "\" annotation of the " + sym +
                     " comment contains @inheritdoc, but the corresponding section in the parent is not defined.")
                 "<invalid inheritdoc annotation>"
             }
@@ -442,7 +442,7 @@ object Comments {
      *  the position of the doc comment of the overridden version is returned instead.
      */
     def docCommentPos(sym: Symbol)(implicit ctx: Context): Span =
-      ctx.docCtx.flatMap(_.docstring(sym).map(_.pos)).getOrElse(NoSpan)
+      ctx.docCtx.flatMap(_.docstring(sym).map(_.span)).getOrElse(NoSpan)
 
     /** A version which doesn't consider self types, as a temporary measure:
      *  an infinite loop has broken out between superComment and cookedDocComment

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

@@ -212,8 +212,8 @@ trait Symbols { this: Context =>
   /** Define a new symbol associated with a Bind or pattern wildcard and
    *  make it gadt narrowable.
    */
-  def newPatternBoundSymbol(name: Name, info: Type, pos: Span): Symbol = {
-    val sym = newSymbol(owner, name, Case, info, coord = pos)
+  def newPatternBoundSymbol(name: Name, info: Type, span: Span): Symbol = {
+    val sym = newSymbol(owner, name, Case, info, coord = span)
     if (name.isTypeName) {
       val bounds = info.bounds
       gadt.addBound(sym, bounds.lo, isUpper = false)
@@ -498,7 +498,7 @@ object Symbols {
 
     /** Does this symbol come from a currently compiled source file? */
     final def isDefinedInCurrentRun(implicit ctx: Context): Boolean =
-      pos.exists && defRunId == ctx.runId && {
+      span.exists && defRunId == ctx.runId && {
         val file = associatedFile
         file != null && ctx.run.files.contains(file)
       }
@@ -663,14 +663,13 @@ object Symbols {
         denot.owner.sourceSymbol
       else this
 
-    /** The position of this symbol, or NoPosition if the symbol was not loaded
+    /** The position of this symbol, or NoSpan if the symbol was not loaded
      *  from source or from TASTY. This is always a zero-extent position.
      *
      *  NOTE: If the symbol was not loaded from the current compilation unit,
      *  the implicit conversion `sourcePos` will return the wrong result, careful!
-     *  TODO: Consider changing this method return type to `SourcePosition`.
      */
-    final def pos: Span = if (coord.isPosition) coord.toPosition else NoSpan
+    final def span: Span = if (coord.isSpan) coord.toSpan else NoSpan
 
     final def sourcePos(implicit ctx: Context): SourcePosition = {
       val source = {
@@ -680,7 +679,7 @@ object Symbols {
           ctx.source
         else ctx.getSource(f)
       }
-      source.atSpan(pos)
+      source.atSpan(span)
     }
 
     // ParamInfo types and methods

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

@@ -23,7 +23,7 @@ class CommentPickler(pickler: TastyPickler, addrOfTree: tpd.Tree => Option[Addr]
       buf.writeAddr(addr)
       buf.writeNat(length)
       buf.writeBytes(bytes, length)
-      buf.writeLongInt(cmt.pos.coords)
+      buf.writeLongInt(cmt.span.coords)
     case other =>
       ()
   }

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -2103,7 +2103,7 @@ object messages {
           case _ /* Signature.FullMatch */ => "\nThe definitions have matching type signatures after erasure."
         }
       } else ""
-      hl"${decl.showLocated} is already defined as ${previousDecl.showDcl} ${if (previousDecl.pos.exists) s"at line ${previousDecl.sourcePos.line + 1}" else ""}." + details
+      hl"${decl.showLocated} is already defined as ${previousDecl.showDcl} ${if (previousDecl.span.exists) s"at line ${previousDecl.sourcePos.line + 1}" else ""}." + details
     }
     val explanation: String = ""
   }

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

@@ -53,7 +53,7 @@ abstract class AccessProxies {
             accessRef.becomes(forwardedArgss.head.head)
           else
             accessRef.appliedToTypes(forwardedTypes).appliedToArgss(forwardedArgss)
-        rhs.withSpan(accessed.pos)
+        rhs.withSpan(accessed.span)
       })
 
   /** Add all needed accessors to the `body` of class `cls` */
@@ -75,8 +75,8 @@ abstract class AccessProxies {
     }
 
     /** A fresh accessor symbol */
-    private def newAccessorSymbol(owner: Symbol, name: TermName, info: Type, pos: Span)(implicit ctx: Context): TermSymbol = {
-      val sym = ctx.newSymbol(owner, name, Synthetic | Method, info, coord = pos).entered
+    private def newAccessorSymbol(owner: Symbol, name: TermName, info: Type, span: Span)(implicit ctx: Context): TermSymbol = {
+      val sym = ctx.newSymbol(owner, name, Synthetic | Method, info, coord = span).entered
       if (sym.allOverriddenSymbols.exists(!_.is(Deferred))) sym.setFlag(Override)
       sym
     }
@@ -85,7 +85,7 @@ abstract class AccessProxies {
     protected def accessorSymbol(owner: Symbol, accessorName: TermName, accessorInfo: Type, accessed: Symbol)(implicit ctx: Context): Symbol = {
       def refersToAccessed(sym: Symbol) = accessedBy.get(sym).contains(accessed)
       owner.info.decl(accessorName).suchThat(refersToAccessed).symbol.orElse {
-        val acc = newAccessorSymbol(owner, accessorName, accessorInfo, accessed.pos)
+        val acc = newAccessorSymbol(owner, accessorName, accessorInfo, accessed.span)
         accessedBy(acc) = accessed
         acc
       }

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

@@ -42,7 +42,7 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
   private val bridgeTarget = newMutableSymbolMap[Symbol]
 
   def bridgePosFor(member: Symbol): SourcePosition =
-    (if (member.owner == root && member.pos.exists) member else root).sourcePos
+    (if (member.owner == root && member.span.exists) member else root).sourcePos
 
   /** Add a bridge between `member` and `other`, where `member` overrides `other`
    *  before erasure, if the following conditions are satisfied.
@@ -90,7 +90,7 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
 
     ctx.debuglog(
       i"""generating bridge from ${other.showLocated}: ${other.info}
-             |to ${member.showLocated}: ${member.info} @ ${member.pos}
+             |to ${member.showLocated}: ${member.info} @ ${member.span}
              |bridge: ${bridge.showLocated} with flags: ${bridge.flags}""")
 
     bridgeTarget(bridge) = member
@@ -107,7 +107,7 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
       else ref.appliedToArgss(argss)
     }
 
-    bridges += DefDef(bridge, bridgeRhs(_).withSpan(bridge.pos))
+    bridges += DefDef(bridge, bridgeRhs(_).withSpan(bridge.span))
   }
 
   /** Add all necessary bridges to template statements `stats`, and remove at the same

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

@@ -250,7 +250,7 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
 
     def setters(mixin: ClassSymbol): List[Tree] =
       for (setter <- mixin.info.decls.filter(setr => setr.isSetter && !was(setr, Deferred)))
-        yield transformFollowing(DefDef(implementation(setter.asTerm), unitLiteral.withSpan(cls.pos)))
+        yield transformFollowing(DefDef(implementation(setter.asTerm), unitLiteral.withSpan(cls.span)))
 
     cpy.Template(impl)(
       constr =

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

@@ -28,13 +28,13 @@ class MixinOps(cls: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
     res
   }
 
-  def superRef(target: Symbol, pos: Span = cls.pos): Tree = {
+  def superRef(target: Symbol, span: Span = cls.span): Tree = {
     val sup = if (target.isConstructor && !target.owner.is(Trait))
       Super(This(cls), tpnme.EMPTY, true)
     else
       Super(This(cls), target.owner.name.asTypeName, false, target.owner)
     //println(i"super ref $target on $sup")
-    ast.untpd.Select(sup.withSpan(pos), target.name)
+    ast.untpd.Select(sup.withSpan(span), target.name)
       .withType(NamedType(sup.tpe, target))
     //sup.select(target)
   }

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

@@ -37,7 +37,7 @@ class NonLocalReturns extends MiniPhase {
   private def nonLocalReturnKey(meth: Symbol)(implicit ctx: Context) =
     nonLocalReturnKeys.getOrElseUpdate(meth,
       ctx.newSymbol(
-        meth, NonLocalReturnKeyName.fresh(), Synthetic, defn.ObjectType, coord = meth.pos))
+        meth, NonLocalReturnKeyName.fresh(), Synthetic, defn.ObjectType, coord = meth.span))
 
   /** Generate a non-local return throw with given return expression from given method.
    *  I.e. for the method's non-local return key, generate:

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

@@ -256,7 +256,7 @@ object PatternMatcher {
       def matchElemsPlan(seqSym: Symbol, args: List[Tree], exact: Boolean, onSuccess: Plan) = {
         val selectors = args.indices.toList.map(idx =>
           ref(seqSym).select(defn.Seq_apply.matchingMember(seqSym.info)).appliedTo(Literal(Constant(idx))))
-        TestPlan(LengthTest(args.length, exact), seqSym, seqSym.pos,
+        TestPlan(LengthTest(args.length, exact), seqSym, seqSym.span,
           matchArgsPlan(selectors, args, onSuccess))
       }
 

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

@@ -94,7 +94,7 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
         case nme.productElement => vrefss => productElementBody(accessors.length, vrefss.head.head)
       }
       ctx.log(s"adding $synthetic to $clazz at ${ctx.phase}")
-      DefDef(synthetic, syntheticRHS(ctx.withOwner(synthetic))).withSpan(ctx.owner.pos.focus)
+      DefDef(synthetic, syntheticRHS(ctx.withOwner(synthetic))).withSpan(ctx.owner.span.focus)
     }
 
     /** The class
@@ -158,7 +158,7 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
      *
      */
     def equalsBody(that: Tree)(implicit ctx: Context): Tree = {
-      val thatAsClazz = ctx.newSymbol(ctx.owner, nme.x_0, Synthetic, clazzType, coord = ctx.owner.pos) // x$0
+      val thatAsClazz = ctx.newSymbol(ctx.owner, nme.x_0, Synthetic, clazzType, coord = ctx.owner.span) // x$0
       def wildcardAscription(tp: Type) = Typed(Underscore(tp), TypeTree(tp))
       val pattern = Bind(thatAsClazz, wildcardAscription(AnnotatedType(clazzType, Annotation(defn.UncheckedAnnot)))) // x$0 @ (_: C @unchecked)
       val comparisons = accessors map { accessor =>
@@ -213,7 +213,7 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
     def caseHashCodeBody(implicit ctx: Context): Tree = {
       val seed = clazz.fullName.toString.hashCode
       if (accessors.nonEmpty) {
-        val acc = ctx.newSymbol(ctx.owner, "acc".toTermName, Mutable | Synthetic, defn.IntType, coord = ctx.owner.pos)
+        val acc = ctx.newSymbol(ctx.owner, "acc".toTermName, Mutable | Synthetic, defn.IntType, coord = ctx.owner.span)
         val accDef = ValDef(acc, Literal(Constant(seed)))
         val mixes = for (accessor <- accessors) yield
           Assign(ref(acc), ref(defn.staticsMethod("mix")).appliedTo(ref(acc), hashImpl(accessor)))

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -1234,7 +1234,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
           // `isSubType` as a TypeVar might get constrained by a TypeRef it's
           // part of.
           val tp1Params = tp1.newLikeThis(tp1.paramNames, tp1.paramInfos, defn.AnyType)
-          fullyDefinedType(tp1Params, "type parameters of alternative", alt1.symbol.pos)
+          fullyDefinedType(tp1Params, "type parameters of alternative", alt1.symbol.span)
 
           val tparams = ctx.newTypeParams(alt1.symbol, tp1.paramNames, EmptyFlags, tp1.instantiateParamInfos(_))
           isAsSpecific(alt1, tp1.instantiate(tparams.map(_.typeRef)), alt2, tp2)

compiler/src/dotty/tools/dotc/typer/Inliner.scala

@@ -698,7 +698,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
       	 */
         def newBinding(sym: TermSymbol, rhs: Tree): Unit = {
           sym.info = rhs.tpe.widenTermRefExpr
-          bindingsBuf += ValDef(sym, constToLiteral(rhs)).withSpan(sym.pos)
+          bindingsBuf += ValDef(sym, constToLiteral(rhs)).withSpan(sym.span)
         }
 
         def searchImplicit(sym: TermSymbol, tpt: Tree) = {