Rename nextId -> nextSymId in Context

... preparing to add a nextTreeId as well.

Author: odersky

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

@@ -2,7 +2,7 @@ package dotty.tools.dotc
 package ast
 
 import util.Positions._
-import core.Contexts.Context
+import core.Contexts.{Context, TreeIds}
 import core.Decorators._
 import core.Flags.{JavaDefined, Extension}
 import core.StdNames.nme
@@ -27,24 +27,26 @@ abstract class Positioned extends Product {
     if (pos.exists) setChildPositions(pos.toSynthetic)
   }
 
+  def cloned(implicit ids: TreeIds): Positioned
+
   /** A positioned item like this one with the position set to `pos`.
    *  if the positioned item is source-derived, a clone is returned.
    *  If the positioned item is synthetic, the position is updated
    *  destructively and the item itself is returned.
    */
-  def withPos(pos: Position): this.type = {
-    val newpd = (if (pos == curPos || curPos.isSynthetic) this else clone.asInstanceOf[Positioned])
+  def withPos(pos: Position)(implicit ids: TreeIds): this.type = {
+    val newpd = if (pos == curPos || curPos.isSynthetic) this else cloned
     newpd.setPos(pos)
     newpd.asInstanceOf[this.type]
   }
 
-  def withPos(posd: Positioned): this.type =
+  def withPos(posd: Positioned)(implicit ids: TreeIds): this.type =
     if (posd == null) this else withPos(posd.pos)
 
   /** This item with a position that's the union of the given `pos` and the
    *  current position.
    */
-  def addPos(pos: Position): this.type = withPos(pos union this.pos)
+  def addPos(pos: Position)(implicit ids: TreeIds): 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.

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

@@ -455,7 +455,7 @@ object Contexts {
     def pendingUnderlying: mutable.HashSet[Type]   = base.pendingUnderlying
     def uniqueNamedTypes: Uniques.NamedTypeUniques = base.uniqueNamedTypes
     def uniques: util.HashSet[Type]                = base.uniques
-    def nextId: Int                        = base.nextId
+    def nextSymId: Int                     = base.nextSymId
 
     def initialize()(implicit ctx: Context): Unit = base.initialize()(ctx)
   }
@@ -626,9 +626,9 @@ object Contexts {
     // Symbols state
 
     /** A counter for unique ids */
-    private[core] var _nextId: Int = 0
+    private[core] var _nextSymId: Int = 0
 
-    def nextId: Int = { _nextId += 1; _nextId }
+    def nextSymId: Int = { _nextSymId += 1; _nextSymId }
 
     /** Sources that were loaded */
     val sources: mutable.HashMap[AbstractFile, SourceFile] = new mutable.HashMap[AbstractFile, SourceFile]

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

@@ -43,11 +43,11 @@ trait Symbols { this: Context =>
    *  it's debug-friendlier not to create an anonymous class here.
    */
   def newNakedSymbol[N <: Name](coord: Coord = NoCoord)(implicit ctx: Context): Symbol { type ThisName = N } =
-    new Symbol(coord, ctx.nextId).asInstanceOf[Symbol { type ThisName = N }]
+    new Symbol(coord, ctx.nextSymId).asInstanceOf[Symbol { type ThisName = N }]
 
   /** Create a class symbol without a denotation. */
   def newNakedClassSymbol(coord: Coord = NoCoord, assocFile: AbstractFile = null)(implicit ctx: Context): ClassSymbol =
-    new ClassSymbol(coord, assocFile, ctx.nextId)
+    new ClassSymbol(coord, assocFile, ctx.nextSymId)
 
 // ---- Symbol creation methods ----------------------------------