Allocate tree ids globally

Tree ids survive compilation runs, need to be allocated globally.

Author: odersky

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

@@ -43,23 +43,23 @@ object desugar {
 
 // ----- DerivedTypeTrees -----------------------------------
 
-  class SetterParamTree(implicit @transientParam ids: TreeIds) extends DerivedTypeTree {
+  class SetterParamTree(implicit @transientParam src: SourceInfo) extends DerivedTypeTree {
     def derivedTree(sym: Symbol)(implicit ctx: Context): tpd.TypeTree = tpd.TypeTree(sym.info.resultType)
   }
 
-  class TypeRefTree(implicit @transientParam ids: TreeIds) extends DerivedTypeTree {
+  class TypeRefTree(implicit @transientParam src: SourceInfo) extends DerivedTypeTree {
     def derivedTree(sym: Symbol)(implicit ctx: Context): tpd.TypeTree = tpd.TypeTree(sym.typeRef)
   }
 
-  class TermRefTree(implicit @transientParam ids: TreeIds) extends DerivedTypeTree {
+  class TermRefTree(implicit @transientParam src: SourceInfo) extends DerivedTypeTree {
     def derivedTree(sym: Symbol)(implicit ctx: Context): tpd.Tree = tpd.ref(sym)
   }
 
   /** A type tree that computes its type from an existing parameter.
    *  @param suffix  String difference between existing parameter (call it `P`) and parameter owning the
    *                 DerivedTypeTree (call it `O`). We have: `O.name == P.name + suffix`.
    */
-  class DerivedFromParamTree(suffix: String)(implicit @transientParam ids: TreeIds) extends DerivedTypeTree {
+  class DerivedFromParamTree(suffix: String)(implicit @transientParam src: SourceInfo) extends DerivedTypeTree {
 
     /** Make sure that for all enclosing module classes their companion classes
      *  are completed. Reason: We need the constructor of such companion classes to
@@ -1025,7 +1025,7 @@ object desugar {
     mayNeedSetter
    }
 
-  private def derivedDefDef(original: Tree, named: NameTree, tpt: Tree, rhs: Tree, mods: Modifiers)(implicit ids: TreeIds) =
+  private def derivedDefDef(original: Tree, named: NameTree, tpt: Tree, rhs: Tree, mods: Modifiers)(implicit src: SourceInfo) =
     DefDef(named.name.asTermName, Nil, Nil, tpt, rhs)
       .withMods(mods)
       .withPos(original.pos.withPoint(named.pos.start))
@@ -1389,6 +1389,6 @@ object desugar {
     buf.toList
   }
 
-  private class IrrefutableGenFrom(pat: Tree, expr: Tree)(implicit @transientParam ids: TreeIds)
+  private class IrrefutableGenFrom(pat: Tree, expr: Tree)(implicit @transientParam src: SourceInfo)
     extends GenFrom(pat, expr)
 }

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

@@ -73,7 +73,7 @@ object DesugarEnums {
     else if (isEnumCase(cdef)) cdef.withMods(cdef.mods.withFlags(cdef.mods.flags | Final))
     else cdef
 
-  private def valuesDot(name: String)(implicit ids: TreeIds) =
+  private def valuesDot(name: String)(implicit src: SourceInfo) =
     Select(Ident(nme.DOLLAR_VALUES), name.toTermName)
   private def registerCall(implicit ctx: Context): List[Tree] =
     if (enumClass.typeParams.nonEmpty) Nil

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, TreeIds}
+import core.Contexts.{Context, SourceInfo}
 import core.Decorators._
 import core.Flags.{JavaDefined, Extension}
 import core.StdNames.nme
@@ -27,26 +27,26 @@ abstract class Positioned extends Product {
     if (pos.exists) setChildPositions(pos.toSynthetic)
   }
 
-  def cloned(implicit ids: TreeIds): Positioned
+  def cloned(implicit src: SourceInfo): 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)(implicit ids: TreeIds): this.type = {
+  def withPos(pos: Position)(implicit src: SourceInfo): this.type = {
     val newpd = if (pos == curPos || curPos.isSynthetic) this else cloned
     newpd.setPos(pos)
     newpd.asInstanceOf[this.type]
   }
 
-  def withPos(posd: Positioned)(implicit ids: TreeIds): this.type =
+  def withPos(posd: Positioned)(implicit src: SourceInfo): 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)(implicit ids: TreeIds): this.type = withPos(pos union this.pos)
+  def addPos(pos: Position)(implicit src: SourceInfo): 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/ast/TreeIds.scala

@@ -0,0 +1,44 @@
+package dotty.tools
+package dotc
+package ast
+
+import core.Contexts.SourceInfo
+import io.AbstractFile
+import scala.annotation.internal.sharable
+import scala.collection.mutable
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicInteger
+
+object TreeIds {
+
+  private final val ChunkSize = 1024
+
+  @sharable private[this] val counters = new ConcurrentHashMap[AbstractFile, AtomicInteger]
+  @sharable private[this] val fileOfChunk = mutable.ArrayBuffer[AbstractFile]()
+
+  def nextId(implicit src: SourceInfo): Int = {
+    val file = src.source.file
+    var ctr = counters.get(file)
+    if (ctr == null) {
+      counters.putIfAbsent(file, new AtomicInteger)
+      ctr = counters.get(file)
+    }
+    def recur(): Int = {
+      val id = ctr.get
+      if (id % ChunkSize == 0) newChunk(file, ctr)
+      else if (ctr.compareAndSet(id, id + 1)) id
+      else recur()
+    }
+    recur()
+  }
+
+  private def newChunk(file: AbstractFile, ctr: AtomicInteger): Int = synchronized {
+    val id = fileOfChunk.length * ChunkSize
+    fileOfChunk += file
+    ctr.set(id + 1)
+    id
+  }
+
+  def fileOfId(id: Int): AbstractFile =
+    fileOfChunk(id / ChunkSize)
+}