Drop uniqueId field in Positioned

Instead, keep a separate weak hashmap if a tree-id option is set.
Since tree ids are now only used for debugging, we do not need to
maintain them as an inline field anymore.

Author: odersky

compiler/src/dotty/tools/dotc/Driver.scala

@@ -70,7 +70,7 @@ class Driver {
     val summary = CompilerCommand.distill(args)(using ictx)
     ictx.setSettings(summary.sstate)
     MacroClassLoader.init(ictx)
-    Positioned.updateDebugPos(using ictx)
+    Positioned.init(using ictx)
 
     inContext(ictx) {
       if !ctx.settings.YdropComments.value || ctx.mode.is(Mode.ReadComments) then

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

@@ -19,31 +19,34 @@ import java.io.{ PrintWriter }
 /** A base class for things that have positions (currently: modifiers and trees)
  */
 abstract class Positioned(implicit @constructorOnly src: SourceFile) extends SrcPos, Product, Cloneable {
+  import Positioned.{ids, nextId, debugId}
 
   private var myUniqueId: Int = _
   private var mySpan: Span = _
 
-  /** A unique identifier. Among other things, used for determining the source file
-   *  component of the position.
+  /** A unique identifier in case -Yshow-tree-ids, or -Ydebug-tree-with-id
+   *  is set, -1 otherwise.
    */
-  def uniqueId: Int = myUniqueId
+  def uniqueId: Int =
+    if ids != null && ids.containsKey(this) then ids.get(this) else -1
 
-  def uniqueId_=(id: Int): Unit = {
-    def printTrace() = {
-      println(s"Debug tree (id=${Positioned.debugId}) creation \n$this\n")
-      Reporter.displayPrompt(Console.in, new PrintWriter(Console.err, true))
-    }
-    if (Positioned.debugId == id) printTrace()
-    myUniqueId = id
-  }
+  private def allocateId() =
+    if ids != null then
+      val ownId = nextId
+      nextId += 1
+      ids.put(this, ownId)
+      if ownId == debugId then
+        println(s"Debug tree (id=$debugId) creation \n$this\n")
+        Reporter.displayPrompt(Console.in, new PrintWriter(Console.err, true))
+
+  allocateId()
 
   /** The span part of the item's position */
   def span: Span = mySpan
 
   def span_=(span: Span): Unit =
     mySpan = span
 
-  uniqueId = src.nextId
   span = envelope(src)
 
   val source: SourceFile = src
@@ -125,7 +128,7 @@ abstract class Positioned(implicit @constructorOnly src: SourceFile) extends Src
   /** Clone this node but assign it a fresh id which marks it as a node in `file`. */
   def cloneIn(src: SourceFile): this.type = {
     val newpd: this.type = clone.asInstanceOf[this.type]
-    newpd.uniqueId = src.nextId
+    newpd.allocateId()
     // assert(newpd.uniqueId != 2208, s"source = $this, ${this.uniqueId}, ${this.span}")
     newpd
   }
@@ -237,8 +240,14 @@ abstract class Positioned(implicit @constructorOnly src: SourceFile) extends Src
 }
 
 object Positioned {
-  @sharable private[Positioned] var debugId = Int.MinValue
+  @sharable private var debugId = Int.MinValue
+  @sharable private var ids: java.util.WeakHashMap[Positioned, Int] = null
+  @sharable private var nextId: Int = 0
 
-  def updateDebugPos(using Context): Unit =
+  def init(using Context): Unit =
     debugId = ctx.settings.YdebugTreeWithId.value
+    if ctx.settings.YshowTreeIds.value
+       || debugId != ctx.settings.YdebugTreeWithId.default
+    then
+      ids = java.util.WeakHashMap()
 }

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

@@ -221,7 +221,7 @@ object Trees {
       }
     }
 
-    override def hashCode(): Int = uniqueId // for debugging; was: System.identityHashCode(this)
+    override def hashCode(): Int = System.identityHashCode(this)
     override def equals(that: Any): Boolean = this eq that.asInstanceOf[AnyRef]
   }
 

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

@@ -70,8 +70,6 @@ object Inliner {
    *            and body that replace it.
    */
   def inlineCall(tree: Tree)(using Context): Tree = {
-    val startId = ctx.source.nextId
-
     if tree.symbol.denot != SymDenotations.NoDenotation
       && tree.symbol.owner.companionModule == defn.CompiletimeTestingPackageObject
     then
@@ -136,10 +134,6 @@ object Inliner {
               |You can use ${setting.name} to change the limit.""",
           (tree :: enclosingInlineds).last.srcPos
         )
-
-    val endId = ctx.source.nextId
-    addInlinedTrees(endId - startId)
-
     tree2
   }
 
@@ -735,6 +729,26 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
       case _ =>
     }
 
+    /** The number of nodes in this tree, excluding code in nested inline
+     *  calls and annotations of definitions.
+     */
+    def treeSize(x: Any): Int =
+      var siz = 0
+      x match
+        case x: Trees.Inlined[_] =>
+        case x: Positioned =>
+          var i = 0
+          while i < x.productArity do
+            siz += treeSize(x.productElement(i))
+            i += 1
+        case x: List[_] =>
+          var xs = x
+          while xs.nonEmpty do
+            siz += treeSize(xs.head)
+            xs = xs.tail
+        case _ =>
+      siz
+
     trace(i"inlining $call", inlining, show = true) {
 
       // The normalized bindings collected in `bindingsBuf`
@@ -758,6 +772,8 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
 
       if (inlinedMethod == defn.Compiletime_error) issueError()
 
+      addInlinedTrees(treeSize(finalExpansion))
+
       // Take care that only argument bindings go into `bindings`, since positions are
       // different for bindings from arguments and bindings from body.
       tpd.Inlined(call, finalBindings, finalExpansion)

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

@@ -181,49 +181,16 @@ class SourceFile(val file: AbstractFile, computeContent: => Array[Char]) extends
   }
 
   override def toString: String = file.toString
-
-  // Positioned ids
-
-  private val ctr = new AtomicInteger
-
-  def nextId: Int = {
-    val id = ctr.get
-    if (id % ChunkSize == 0) newChunk
-    else if (ctr.compareAndSet(id, id + 1)) id
-    else nextId
-  }
-
-  private def newChunk: Int = sourceOfChunk.synchronized {
-    val id = chunks << ChunkSizeLog
-    if (chunks == sourceOfChunk.length) {
-      val a = new Array[SourceFile](chunks * 2)
-      System.arraycopy(sourceOfChunk, 0, a, 0, chunks)
-      sourceOfChunk = a
-    }
-    sourceOfChunk(chunks) = this
-    chunks += 1
-    ctr.set(id + 1)
-    id
-  }
 }
 object SourceFile {
   implicit def eqSource: Eql[SourceFile, SourceFile] = Eql.derived
 
   implicit def fromContext(using Context): SourceFile = ctx.source
 
-  def fromId(id: Int): SourceFile = sourceOfChunk(id >> ChunkSizeLog)
-
   def virtual(name: String, content: String, maybeIncomplete: Boolean = false) =
     val src = new SourceFile(new VirtualFile(name, content.getBytes(StandardCharsets.UTF_8)), scala.io.Codec.UTF8)
     src._maybeInComplete = maybeIncomplete
     src
-
-  private final val ChunkSizeLog = 10
-  private final val ChunkSize = 1 << ChunkSizeLog
-
-  // These two vars are sharable because they're only used in the synchronized block in newChunk
-  @sharable private var chunks: Int = 0
-  @sharable private var sourceOfChunk: Array[SourceFile] = new Array[SourceFile](2000)
 }
 
 @sharable object NoSource extends SourceFile(NoAbstractFile, Array[Char]()) {