minimalist refactoring to allow annotating trees

not tested for performance, but shouldn't add any memory overhead

see https://github.com/adriaanm/scala/commit/44362c557f for an example usage

3 files changed, 26 insertions, 1 deletions

diff --git a/src/compiler/scala/reflect/runtime/Universe.scala b/src/compiler/scala/reflect/runtime/Universe.scala
index 324fee87ab..7a5dda3d8e 100644
--- a/src/compiler/scala/reflect/runtime/Universe.scala
+++ b/src/compiler/scala/reflect/runtime/Universe.scala
@@ -39,6 +39,11 @@ class Universe extends SymbolTable {
 
   definitions.AnyValClass // force it.
 
+  type TreeAnnotation = Position
+  val NoTreeAnnotation: TreeAnnotation = NoPosition
+  def positionToAnnotation(pos: Position): TreeAnnotation = pos // TODO
+  def annotationToPosition(annot: TreeAnnotation): Position = annot //TODO
+
   // establish root association to avoid cyclic dependency errors later
   classToScala(classOf[java.lang.Object]).initialize
 
diff --git a/src/compiler/scala/tools/nsc/symtab/Positions.scala b/src/compiler/scala/tools/nsc/symtab/Positions.scala
index c96c709fb0..680b06f8ce 100644
--- a/src/compiler/scala/tools/nsc/symtab/Positions.scala
+++ b/src/compiler/scala/tools/nsc/symtab/Positions.scala
@@ -14,6 +14,15 @@ self: scala.tools.nsc.symtab.SymbolTable =>
   type Position = scala.tools.nsc.util.Position
   val NoPosition = scala.tools.nsc.util.NoPosition
 
+  type TreeAnnotation = scala.tools.nsc.util.TreeAnnotation
+  val NoTreeAnnotation: TreeAnnotation                      = NoPosition
+  def positionToAnnotation(pos: Position): TreeAnnotation   = pos
+  def annotationToPosition(annot: TreeAnnotation): Position = annot.pos
+  override def _checkSetAnnotation(tree: Tree, annot: TreeAnnotation): Unit = {
+    if (tree.pos != NoPosition && tree.pos != annot.pos) debugwarn("Overwriting annotation "+ tree.annotation +" of tree "+ tree +" with annotation "+ annot)
+    // if ((tree.annotation.isInstanceOf[scala.tools.nsc.util.Position] || !annot.isInstanceOf[scala.tools.nsc.util.Position]) && tree.isInstanceOf[Block])
+    //   println("Updating block from "+ tree.annotation +" to "+ annot)
+  }
   def focusPos(pos: Position): Position = pos.focus
   def isRangePos(pos: Position): Boolean = pos.isRange
   def showPos(pos: Position): String = pos.show
diff --git a/src/compiler/scala/tools/nsc/util/Position.scala b/src/compiler/scala/tools/nsc/util/Position.scala
index 53c767be20..bc74717366 100644
--- a/src/compiler/scala/tools/nsc/util/Position.scala
+++ b/src/compiler/scala/tools/nsc/util/Position.scala
@@ -33,6 +33,16 @@ object Position {
   }
 }
 
+/**
+ * A tree does not directly store a Position. It stores a TreeAnnotation, which /typically/ is a Position.
+ *
+ * A TreeAnnotion may encompass more than just a Position, though, depending on the exact subclass of TreeAnnotation.
+ */
+trait TreeAnnotation {
+  def pos: Position
+}
+
+
 /** The Position class and its subclasses represent positions of ASTs and symbols.
  *  Except for NoPosition and FakePos, every position refers to a SourceFile
  *  and to an offset in the sourcefile (its `point`). For batch compilation,
@@ -77,7 +87,8 @@ object Position {
  *  pos.makeTransparent converts an opaque range position into a transparent one.
  *                      returns all other positions unchanged.
  */
-trait Position {
+trait Position extends TreeAnnotation {
+  def pos: Position = this
 
   /** An optional value containing the source file referred to by this position, or
    *  None if not defined.