Move attachments to a separate hashmap

This saves 4 bytes per tree. Let's see whether that makes a
difference, performance-wise.

Author: odersky

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

@@ -118,21 +118,23 @@ class Run(comp: Compiler, ictx: Context) {
     ctx.usePhases(phases)
     var lastPrintedTree: PrintedTree = NoPrintedTree
     for (phase <- ctx.allPhases)
-      if (phase.isRunnable) {
-        val start = System.currentTimeMillis
-        units = phase.runOn(units)
-        if (ctx.settings.Xprint.value.containsPhase(phase)) {
-          for (unit <- units) {
-            lastPrintedTree =
-              printTree(lastPrintedTree)(ctx.fresh.setPhase(phase.next).setCompilationUnit(unit))
+      if (phase.isRunnable)
+        Stats.trackTime(s"$phase ms ") {
+          val start = System.currentTimeMillis
+          units = phase.runOn(units)
+          if (ctx.settings.Xprint.value.containsPhase(phase)) {
+            for (unit <- units) {
+              lastPrintedTree =
+                printTree(lastPrintedTree)(ctx.fresh.setPhase(phase.next).setCompilationUnit(unit))
+            }
           }
+          ctx.informTime(s"$phase ", start)
+          Stats.record(s"trees created at end of $phase:", ast.Trees.ntrees)
+		  for (unit <- units)
+      		Stats.record("retained typed trees at end of $phase", unit.tpdTree.treeSize)
         }
-        ctx.informTime(s"$phase ", start)
-      }
     if (!ctx.reporter.hasErrors) Rewrites.writeBack()
-    for (unit <- units)
-      Stats.record("retained typed trees at end", unit.tpdTree.treeSize)
-    Stats.record("total trees at end", ast.Trees.ntrees)
+    Stats.record("attachments at end", ctx.attachments.size)
   }
 
   private sealed trait PrintedTree

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

@@ -87,12 +87,12 @@ object desugar {
   }
 
   /** A type definition copied from `tdef` with a rhs typetree derived from it */
-  def derivedTypeParam(tdef: TypeDef) =
+  def derivedTypeParam(tdef: TypeDef)(implicit ctx: Context) =
     cpy.TypeDef(tdef)(
       rhs = new DerivedFromParamTree() withPos tdef.rhs.pos watching tdef)
 
   /** A value definition copied from `vdef` with a tpt typetree derived from it */
-  def derivedTermParam(vdef: ValDef) =
+  def derivedTermParam(vdef: ValDef)(implicit ctx: Context) =
     cpy.ValDef(vdef)(
       tpt = new DerivedFromParamTree() withPos vdef.tpt.pos watching vdef)
 

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

@@ -56,7 +56,7 @@ object Trees {
    */
   abstract class Tree[-T >: Untyped] extends Positioned
                                         with Product
-                                        with Attachment.Container
+                                        with Attachment.Surface
                                         with printing.Showable
                                         with Cloneable {
 
@@ -311,7 +311,7 @@ object Trees {
     private[dotc] def rawMods: untpd.Modifiers =
       if (myMods == null) untpd.EmptyModifiers else myMods
 
-    def rawComment: Option[Comment] = getAttachment(DocComment)
+    def rawComment(implicit ctx: Context): Option[Comment] = getAttachment(DocComment)
 
     def withMods(mods: untpd.Modifiers): ThisTree[Untyped] = {
       val tree = if (myMods == null || (myMods == mods)) this else clone.asInstanceOf[MemberDef[Untyped]]
@@ -321,7 +321,7 @@ object Trees {
 
     def withFlags(flags: FlagSet): ThisTree[Untyped] = withMods(untpd.Modifiers(flags))
 
-    def setComment(comment: Option[Comment]): ThisTree[Untyped] = {
+    def setComment(comment: Option[Comment])(implicit ctx: Context): ThisTree[Untyped] = {
       comment.map(putAttachment(DocComment, _))
       asInstanceOf[ThisTree[Untyped]]
     }

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

@@ -211,9 +211,9 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     def watched: Tree = myWatched
 
     /** Install the derived type tree as a dependency on `original` */
-    def watching(original: DefTree): this.type = {
+    def watching(original: DefTree)(implicit ctx: Context): this.type = {
       myWatched = original
-      val existing = original.attachmentOrElse(References, Nil)
+      val existing = original.getAttachment(References).getOrElse(Nil)
       original.putAttachment(References, this :: existing)
       this
     }

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

@@ -32,6 +32,7 @@ import config.{Settings, ScalaSettings, Platform, JavaPlatform}
 import language.implicitConversions
 import DenotTransformers.DenotTransformer
 import util.Property.Key
+import util.Attachment
 import xsbti.AnalysisCallback
 
 object Contexts {
@@ -652,6 +653,11 @@ object Contexts {
 
     private[core] var denotTransformers: Array[DenotTransformer] = _
 
+    // Trees state
+
+    private[dotc] val attachments =
+      new java.util.IdentityHashMap[Attachment.Surface, Map[Key[_], Any]]
+
     // Printers state
     /** Number of recursive invocations of a show method on current stack */
     private[dotc] var toTextRecursions = 0
@@ -664,6 +670,7 @@ object Contexts {
     def reset() = {
       for ((_, set) <- uniqueSets) set.clear()
       errorTypeMsg.clear()
+      attachments.clear()
     }
 
     // Test that access is single threaded

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

@@ -68,7 +68,7 @@ trait NamerContextOps { this: Context =>
     def go(ctx: Context): Symbol = {
       ctx.typeAssigner match {
         case typer: Typer =>
-          tree.getAttachment(typer.SymOfTree) match {
+          tree.getAttachment(typer.SymOfTree)(ctx) match {
             case Some(sym) => sym
             case None =>
               var cx = ctx.outer
@@ -226,7 +226,7 @@ class Namer { typer: Typer =>
 
   /** Record `sym` as the symbol defined by `tree` */
   def recordSym(sym: Symbol, tree: Tree)(implicit ctx: Context): Symbol = {
-    val refs = tree.attachmentOrElse(References, Nil)
+    val refs = tree.getAttachment(References).getOrElse(Nil)
     if (refs.nonEmpty) {
       tree.removeAttachment(References)
       refs foreach (_.pushAttachment(OriginalSymbol, sym))
@@ -373,7 +373,7 @@ class Namer { typer: Typer =>
 
   /** The expanded version of this tree, or tree itself if not expanded */
   def expanded(tree: Tree)(implicit ctx: Context): Tree = tree match {
-    case ddef: DefTree => ddef.attachmentOrElse(ExpandedTree, ddef)
+    case ddef: DefTree => ddef.getAttachment(ExpandedTree).getOrElse(ddef)
     case _ => tree
   }
 

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

@@ -1,99 +1,73 @@
-package dotty.tools.dotc.util
+package dotty.tools.dotc
+package util
+
+import Property.Key
+import core.Contexts.Context
+
+/** Typed Key/Value pairs */
+case class Attachment[V](key: Key[V], value: V) {
+  Stats.record("attachment")
+}
 
-/** A class inheriting from Attachment.Container supports
- *  adding, removing and lookup of attachments. Attachments are typed key/value pairs.
- */
 object Attachment {
-  import Property.Key
 
-  /** An implementation trait for attachments.
-   *  Clients should inherit from Container instead.
-   */
-  trait LinkSource {
-    private[Attachment] var next: Link[_]
+  /** A surface to which attachments can be attached */
+  trait Surface {
 
     /** Optionally get attachment corresponding to `key` */
-    final def getAttachment[V](key: Key[V]): Option[V] = {
-      val nx = next
-      if (nx == null) None
-      else if (nx.key eq key) Some(nx.value.asInstanceOf[V])
-      else nx.getAttachment[V](key)
+    final def getAttachment[V](key: Key[V])(implicit ctx: Context): Option[V] = {
+      val as = ctx.attachments.get(this)
+      if (as == null) None
+      else as.get(key).asInstanceOf[Option[V]]
     }
 
     /** The attachment corresponding to `key`.
      *  @throws NoSuchElementException  if no attachment with key exists
      */
-    final def attachment[V](key: Key[V]): V = {
-      val nx = next
-      if (nx == null) throw new NoSuchElementException
-      else if (nx.key eq key) nx.value.asInstanceOf[V]
-      else nx.attachment(key)
-    }
-
-    /** The attachment corresponding to `key`, or `default`
-     *  if no attachment with `key` exists.
-     */
-    final def attachmentOrElse[V](key: Key[V], default: V): V = {
-      val nx = next
-      if (nx == null) default
-      else if (nx.key eq key) nx.value.asInstanceOf[V]
-      else nx.attachmentOrElse(key, default)
-    }
+    final def attachment[V](key: Key[V])(implicit ctx: Context): V =
+      getAttachment(key).get
 
     /** Add attachment with given `key` and `value`.
      *  @return  Optionally, the old attachment with given `key` if one existed before.
      *  The new attachment is added at the position of the old one, or at the end
      *  if no attachment with same `key` existed.
      */
-    final def putAttachment[V](key: Key[V], value: V): Option[V] = {
-      val nx = next
-      if (nx == null) {
-        next = new Link(key, value, null)
-        None
-      }
-      else if (nx.key eq key) {
-        next = new Link(key, value, nx.next)
-        Some(nx.value.asInstanceOf[V])
-      }
-      else nx.putAttachment(key, value)
+    final def putAttachment[V](key: Key[V], value: V)(implicit ctx: Context): Option[V] = {
+      val as = ctx.attachments.get(this)
+      val m: Map[Key[_], Any] = if (as == null) Map.empty else as // Do we need the type annotation?
+      ctx.attachments.put(this, m.updated(key, value))
+      m.get(key).asInstanceOf[Option[V]]
+    }
+
+    final def pushAttachment[V](key: Key[V], value: V)(implicit ctx: Context): Unit = {
+      assert(!getAttachment(key).isDefined, s"duplicate attachment for key $key")
+      putAttachment(key, value)
     }
 
     /** Remove attachment with given `key`, if it exists.
      *  @return  Optionally, the removed attachment with given `key` if one existed before.
      */
-    final def removeAttachment[V](key: Key[V]): Option[V] = {
-      val nx = next
-      if (nx == null)
-        None
-      else if (nx.key eq key) {
-        next = nx.next
-        Some(nx.value.asInstanceOf[V])
+    final def removeAttachment[V](key: Key[V])(implicit ctx: Context): Option[V] = {
+      val as = ctx.attachments.get(this)
+      if (as == null) None
+      else as.get(key) match {
+        case None => None
+        case some =>
+          val m = as - key
+          if (m.isEmpty) ctx.attachments.remove(this)
+          else ctx.attachments.put(this, m)
+          some.asInstanceOf[Option[V]]
       }
-      else nx.removeAttachment(key)
     }
 
-    /** The list of all keys and values attached to this container. */
-    final def allAttachments: List[(Key[_], Any)] = {
-      val nx = next
-      if (nx == null) Nil else (nx.key, nx.value) :: nx.allAttachments
-    }
-  }
-
-  /** A private, concrete implementation class linking attachments.
-   */
-  private[Attachment] class Link[+V](val key: Key[V], val value: V, var next: Link[_])
-      extends LinkSource
-
-  /** A trait for objects that can contain attachments */
-  trait Container extends LinkSource {
-    private[Attachment] var next: Link[_] = null
-
-    final def pushAttachment[V](key: Key[V], value: V): Unit = {
-      assert(!getAttachment(key).isDefined, s"duplicate attachment for key $key")
-      next = new Link(key, value, next)
+    /** The list of all keys and values attached to this surface. */
+    final def allAttachments(implicit ctx: Context): List[(Key[_], Any)] = {
+      val as = ctx.attachments.get(this)
+      if (as == null) Nil
+      else as.toList
     }
 
-    final def removeAllAttachments() =
-      next = null
+    final def removeAllAttachments()(implicit ctx: Context) =
+      ctx.attachments.remove(this)
   }
 }

compiler/test/dotty/tools/dotc/parsing/DocstringTest.scala

@@ -25,10 +25,9 @@ trait DocstringTest extends DottyTest {
       assert(false, s"Couldn't match resulting AST to expected AST in: $x")
   }
 
-  def checkFrontend(source: String)(docAssert: PartialFunction[Tree[Untyped], Unit]): Unit = {
+  def checkFrontend(source: String)(docAssert: Context => PartialFunction[Tree[Untyped], Unit]): Unit = {
     checkCompile("frontend", source) { (_, ctx) =>
-      implicit val c: Context = ctx
-      (docAssert orElse defaultAssertion)(ctx.compilationUnit.untpdTree)
+      (docAssert(ctx) orElse defaultAssertion)(ctx.compilationUnit.untpdTree)
     }
   }
 }