Add source component to Positioned

Author: odersky

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

@@ -1,44 +1,78 @@
-package dotty.tools.dotc
+package dotty.tools
+package dotc
 package ast
 
 import util.Positions._
-import util.SourcePosition
+import util.{SourceFile, SourcePosition}
 import core.Contexts.{Context, SourceInfo}
 import core.Decorators._
 import core.Flags.{JavaDefined, Extension}
 import core.StdNames.nme
+import io.AbstractFile
+import annotation.transientParam
+import annotation.internal.sharable
 
 /** A base class for things that have positions (currently: modifiers and trees)
  */
-abstract class Positioned extends Product {
+abstract class Positioned(implicit @transientParam src: SourceInfo) extends Product with Cloneable {
 
+  /** A unique identifier. Among other things, used for determining the source file
+   *  component of the position.
+   */
+  private var myUniqueId: Int = _
   private[this] var curPos: Position = _
 
-  setPos(initialPos)
-
-  /** The item's position.
-   */
+  /** The item's position */
   def pos: Position = curPos
 
- /** Destructively update `curPos` to given position. Also, set any missing
+  /** item's id */
+  def uniqueId: Int = myUniqueId
+
+  protected def srcfile: AbstractFile = TreeIds.fileOfId(uniqueId)
+  def source(implicit ctx: Context): SourceFile = ctx.getSource(srcfile)
+  def sourcePos(implicit ctx: Context): SourcePosition = source.atPos(pos)
+
+  setId(TreeIds.nextIdFor(initialFile(src)))
+  setPos(initialPos, srcfile)
+
+  protected def setId(id: Int): Unit = myUniqueId = id
+
+  /** Destructively update `curPos` to given position. Also, set any missing
    *  positions in children.
    */
-  protected def setPos(pos: Position): Unit = {
-    setPosUnchecked(pos)
-    if (pos.exists) setChildPositions(pos.toSynthetic)
+  protected def setPos(pos: Position, file: AbstractFile): Unit = {
+    setPosUnchecked(pos, file)
+    if (pos.exists) setChildPositions(pos.toSynthetic, file)
   }
 
-  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 src: SourceInfo): this.type = {
-    val newpd = if (pos == curPos || curPos.isSynthetic) this else cloned
-    newpd.setPos(pos)
-    newpd.asInstanceOf[this.type]
+    val ownPos = this.pos
+    val newpd: this.type = if (pos == ownPos || ownPos.isSynthetic) this else cloneIn(srcfile)
+    newpd.setPos(pos, srcfile)
+    newpd
+  }
+
+  def withPos(posd: Positioned)(implicit ctx: Context): this.type = {
+    val ownPos = this.pos
+    val newpd: this.type =
+      if (posd.source == source && posd.pos == ownPos || ownPos.isSynthetic) this
+      else cloneIn(posd.srcfile)
+    newpd.setPos(posd.pos, posd.srcfile)
+    newpd
+  }
+
+  def withSourcePos(sourcePos: SourcePosition)(implicit ctx: Context): this.type = {
+    val ownPos = this.pos
+    val newpd: this.type =
+      if (sourcePos.source == source && sourcePos.pos == ownPos || ownPos.isSynthetic) this
+      else cloneIn(sourcePos.source.file)
+    newpd.setPos(sourcePos.pos, sourcePos.source.file)
+    newpd
   }
 
   /** This item with a position that's the union of the given `pos` and the
@@ -50,7 +84,10 @@ abstract class Positioned extends Product {
    *  any checks of consistency with - or updates of - other positions.
    *  Called from Unpickler when entering positions.
    */
-  private[dotc] def setPosUnchecked(pos: Position): Unit = curPos = pos
+  private[dotc] def setPosUnchecked(pos: Position, file: AbstractFile = this.srcfile): Unit = {
+    if (file != this.srcfile) setId(TreeIds.nextIdFor(file))
+    curPos = pos
+  }
 
   /** If any children of this node do not have positions,
    *  fit their positions between the positions of the known subtrees
@@ -63,7 +100,7 @@ abstract class Positioned extends Product {
    *  But since mutual tail recursion is not supported in Scala, we express it instead
    *  as a while loop with a termination by return in the middle.
    */
-  private def setChildPositions(pos: Position): Unit = {
+  private def setChildPositions(pos: Position, file: AbstractFile): Unit = {
     var n = productArity                    // subnodes are analyzed right to left
     var elems: List[Any] = Nil              // children in lists still to be considered, from right to left
     var end = pos.end                       // the last defined offset, fill in positions up to this offset
@@ -75,10 +112,10 @@ abstract class Positioned extends Product {
         // synthetic. We can preserve this invariant by always setting a
         // zero-extent position for these trees here.
         if (!p.pos.exists || p.pos.isZeroExtent) {
-          p.setPos(Position(start, start))
+          p.setPos(Position(start, start), file)
           fillIn(ps1, start, end)
         } else {
-          p.setPos(Position(start, end))
+          p.setPos(Position(start, end), file)
           fillIn(ps1, end, end)
         }
       case nil =>
@@ -114,6 +151,31 @@ abstract class Positioned extends Product {
     }
   }
 
+  protected def cloneIn(file: AbstractFile): this.type = {
+    val newpd: this.type = clone.asInstanceOf[this.type]
+    newpd.setId(TreeIds.nextIdFor(file))
+    newpd
+  }
+
+  def initialFile(src: SourceInfo): AbstractFile = {
+    def firstFile(x: Any): AbstractFile = x match {
+      case x: Positioned if x.pos.exists =>
+        x.srcfile
+      case x1 :: xs1 =>
+        val f = firstFile(x1)
+        if (f != null) f else firstFile(xs1)
+      case _ =>
+        null
+    }
+    def firstElemFile(n: Int): AbstractFile =
+      if (n == productArity) src.source.file
+      else {
+        val f = firstFile(productElement(n))
+        if (f != null) f else firstElemFile(n + 1)
+      }
+    firstElemFile(0)
+  }
+
   /** The initial, synthetic position. This is usually the union of all positioned children's positions.
    */
   def initialPos: Position = {
@@ -122,7 +184,7 @@ abstract class Positioned extends Product {
     while (n > 0) {
       n -= 1
       productElement(n) match {
-        case p: Positioned => pos = pos union p.pos
+        case p: Positioned if sameSource(p) => pos = pos union p.pos
         case m: untpd.Modifiers => pos = unionPos(unionPos(pos, m.mods), m.annotations)
         case xs: List[_] => pos = unionPos(pos, xs)
         case _ =>
@@ -132,12 +194,14 @@ abstract class Positioned extends Product {
   }
 
   private def unionPos(pos: Position, xs: List[_]): Position = xs match {
-    case (p: Positioned) :: xs1 => unionPos(pos union p.pos, xs1)
+    case (p: Positioned) :: xs1 if sameSource(p) => unionPos(pos union p.pos, xs1)
     case (xs0: List[_]) :: xs1 => unionPos(unionPos(pos, xs0), xs1)
     case _ :: xs1 => unionPos(pos, xs1)
     case _ => pos
   }
 
+  private def sameSource(that: Positioned) = srcfile == that.srcfile
+
   def contains(that: Positioned): Boolean = {
     def isParent(x: Any): Boolean = x match {
       case x: Positioned =>

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

@@ -16,8 +16,9 @@ object TreeIds {
   @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
+  def nextId(implicit src: SourceInfo): Int = nextIdFor(src.source.file)
+
+  def nextIdFor(file: AbstractFile): Int = {
     var ctr = counters.get(file)
     if (ctr == null) {
       counters.putIfAbsent(file, new AtomicInteger)

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

@@ -15,6 +15,7 @@ import io.AbstractFile
 import annotation.internal.sharable
 import annotation.unchecked.uncheckedVariance
 import annotation.transientParam
+import Decorators._
 
 object Trees {
 
@@ -55,42 +56,10 @@ object Trees {
   extends Positioned
      with Product
      with Attachment.Container
-     with printing.Showable
-     with Cloneable {
+     with printing.Showable {
 
     if (Stats.enabled) ntrees += 1
 
-    /** A unique identifier for this tree. Used for debugging, and potentially
-     *  tracking presentation compiler interactions.
-     */
-    @sharable private var myUniqueId: Int = TreeIds.nextId
-
-    def uniqueId: Int = myUniqueId
-
-    def source(implicit ctx: Context): SourceFile = ctx.getSource(TreeIds.fileOfId(uniqueId))
-
-    def sourcePos(implicit ctx: Context): SourcePosition = source.atPos(pos)
-
-    def withPos(posd: Tree[_])(implicit ctx: Context): this.type = {
-      val tree1 =
-        if (posd.source == source && (posd.pos == pos || posd.pos.isSynthetic)) this
-        else cloned(ctx.withSource(posd.source))
-      tree1.setPos(sourcePos.pos)
-      tree1.asInstanceOf[this.type]
-    }
-
-    def withSource(source: SourceFile)(implicit ctx: Context): Tree[T] =
-      if (source == this.source) this
-      else cloned(ctx.withSource(source))
-
-    def withSourcePos(sourcePos: SourcePosition)(implicit ctx: Context): this.type = {
-      val tree1 =
-        if (sourcePos.source == source && (sourcePos.pos == pos || pos.isSynthetic)) this
-        else cloned(ctx.withSource(sourcePos.source))
-      tree1.setPos(sourcePos.pos)
-      tree1.asInstanceOf[this.type]
-    }
-
     /** The type  constructor at the root of the tree */
     type ThisTree[T >: Untyped] <: Tree[T]
 
@@ -160,7 +129,7 @@ object Trees {
       val tree =
         (if (myTpe == null ||
           (myTpe.asInstanceOf[AnyRef] eq tpe.asInstanceOf[AnyRef])) this
-         else clone).asInstanceOf[Tree[Type]]
+         else cloneIn(srcfile)).asInstanceOf[Tree[Type]]
       tree overwriteType tpe
       tree.asInstanceOf[ThisTree[Type]]
     }
@@ -256,12 +225,6 @@ object Trees {
 
     override def hashCode(): Int = uniqueId // for debugging; was: System.identityHashCode(this)
     override def equals(that: Any): Boolean = this eq that.asInstanceOf[AnyRef]
-
-    override def cloned(implicit src: SourceInfo): Tree[T] = {
-      val tree = clone.asInstanceOf[Tree[T]]
-      tree.myUniqueId = TreeIds.nextId
-      tree
-    }
   }
 
   class UnAssignedTypeException[T >: Untyped](tree: Tree[T]) extends RuntimeException {
@@ -357,7 +320,7 @@ object Trees {
     def rawComment: Option[Comment] = getAttachment(DocComment)
 
     def withMods(mods: untpd.Modifiers): ThisTree[Untyped] = {
-      val tree = if (myMods == null || (myMods == mods)) this else clone.asInstanceOf[MemberDef[Untyped]]
+      val tree = if (myMods == null || (myMods == mods)) this else cloneIn(srcfile)
       tree.setMods(mods)
       tree.asInstanceOf[ThisTree[Untyped]]
     }
@@ -809,9 +772,7 @@ object Trees {
   trait WithoutTypeOrPos[-T >: Untyped] extends Tree[T] {
     override def withTypeUnchecked(tpe: Type): ThisTree[Type] = this.asInstanceOf[ThisTree[Type]]
     override def pos: Position = NoPosition
-    override def setPos(pos: Position): Unit = {}
-    override def withSource(source: SourceFile)(implicit ctx: Context): Tree[T] = this
-    override def withSourcePos(sourcePos: SourcePosition)(implicit ctx: Context): this.type = this
+    override def setPos(pos: Position, file: AbstractFile): Unit = {}
   }
 
   /** Temporary class that results from translation of ModuleDefs

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

@@ -108,36 +108,35 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     *
     * For any query about semantic information, check `flags` instead.
     */
-  sealed abstract class Mod(val flags: FlagSet) extends Positioned {
-    def cloned(implicit src: SourceInfo): Positioned = clone.asInstanceOf[Positioned]
-  }
+  sealed abstract class Mod(val flags: FlagSet)(implicit @transientParam src: SourceInfo)
+  extends Positioned
 
   object Mod {
-    case class Private() extends Mod(Flags.Private)
+    case class Private()(implicit @transientParam src: SourceInfo) extends Mod(Flags.Private)
 
-    case class Protected() extends Mod(Flags.Protected)
+    case class Protected()(implicit @transientParam src: SourceInfo) extends Mod(Flags.Protected)
 
-    case class Var() extends Mod(Flags.Mutable)
+    case class Var()(implicit @transientParam src: SourceInfo) extends Mod(Flags.Mutable)
 
-    case class Implicit() extends Mod(Flags.ImplicitCommon)
+    case class Implicit()(implicit @transientParam src: SourceInfo) extends Mod(Flags.ImplicitCommon)
 
-    case class Erased() extends Mod(Flags.Erased)
+    case class Erased()(implicit @transientParam src: SourceInfo) extends Mod(Flags.Erased)
 
-    case class Final() extends Mod(Flags.Final)
+    case class Final()(implicit @transientParam src: SourceInfo) extends Mod(Flags.Final)
 
-    case class Sealed() extends Mod(Flags.Sealed)
+    case class Sealed()(implicit @transientParam src: SourceInfo) extends Mod(Flags.Sealed)
 
-    case class Opaque() extends Mod(Flags.Opaque)
+    case class Opaque()(implicit @transientParam src: SourceInfo) extends Mod(Flags.Opaque)
 
-    case class Override() extends Mod(Flags.Override)
+    case class Override()(implicit @transientParam src: SourceInfo) extends Mod(Flags.Override)
 
-    case class Abstract() extends Mod(Flags.Abstract)
+    case class Abstract()(implicit @transientParam src: SourceInfo) extends Mod(Flags.Abstract)
 
-    case class Lazy() extends Mod(Flags.Lazy)
+    case class Lazy()(implicit @transientParam src: SourceInfo) extends Mod(Flags.Lazy)
 
-    case class Inline() extends Mod(Flags.Inline)
+    case class Inline()(implicit @transientParam src: SourceInfo) extends Mod(Flags.Inline)
 
-    case class Enum() extends Mod(Flags.Enum)
+    case class Enum()(implicit @transientParam src: SourceInfo) extends Mod(Flags.Enum)
   }
 
   /** Modifiers and annotations for definitions
@@ -151,7 +150,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     flags: FlagSet = EmptyFlags,
     privateWithin: TypeName = tpnme.EMPTY,
     annotations: List[Tree] = Nil,
-    mods: List[Mod] = Nil) extends Cloneable {
+    mods: List[Mod] = Nil) {
 
     def is(fs: FlagSet): Boolean = flags is fs
     def is(fc: FlagConjunction): Boolean = flags is fc
@@ -207,9 +206,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
     def isEnumCase: Boolean = isEnum && is(Case)
     def isEnumClass: Boolean = isEnum && !is(Case)
-
-    override def cloned(implicit src: SourceInfo): Modifiers =
-      clone.asInstanceOf[Modifiers]
   }
 
   @sharable val EmptyModifiers: Modifiers = new Modifiers()

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

@@ -39,6 +39,7 @@ object Contexts {
 
   trait SourceInfo {
     def source: SourceFile
+    def withSource(file: AbstractFile): SourceInfo
   }
 
   private val (compilerCallbackLoc, store1) = Store.empty.newLocation[CompilerCallback]()

compiler/src/dotty/tools/dotc/transform/ByNameClosures.scala

@@ -28,7 +28,7 @@ class ByNameClosures extends TransformByNameApply with IdentityDenotTransformer
   override def mkByNameClosure(arg: Tree, argType: Type)(implicit ctx: Context): Tree = {
     val meth = ctx.newSymbol(
       ctx.owner, nme.ANON_FUN, Synthetic | Method, MethodType(Nil, Nil, argType))
-    Closure(meth, _ => arg.changeOwnerAfter(ctx.owner, meth, thisPhase))
+    Closure(meth, _ => arg.changeOwnerAfter(ctx.owner, meth, thisPhase)).withPos(arg)
   }
 }
 

compiler/src/dotty/tools/dotc/transform/TransformByNameApply.scala

@@ -43,7 +43,8 @@ abstract class TransformByNameApply extends MiniPhase { thisPhase: DenotTransfor
       case formalExpr: ExprType =>
         var argType = arg.tpe.widenIfUnstable
         if (defn.isBottomType(argType)) argType = formal.widenExpr
-        def wrap(arg: Tree) = ref(defn.cbnArg).appliedToType(argType).appliedTo(arg)
+        def wrap(arg: Tree) =
+          ref(defn.cbnArg).appliedToType(argType).appliedTo(arg).withPos(arg)
         arg match {
           case Apply(Select(qual, nme.apply), Nil)
           if qual.tpe.derivesFrom(defn.FunctionClass(0)) && isPureExpr(qual) =>

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

@@ -57,7 +57,7 @@ object Typer {
   /** Assert tree has a position, unless it is empty or a typed splice */
   def assertPositioned(tree: untpd.Tree)(implicit ctx: Context): Unit =
     if (!tree.isEmpty && !tree.isInstanceOf[untpd.TypedSplice] && ctx.typerState.isGlobalCommittable)
-      assert(tree.pos.exists, s"position not set for $tree # ${tree.uniqueId}")
+      assert(tree.pos.exists, s"position not set for $tree # ${tree.uniqueId} in ${tree.source}")
 
   /** A context property that indicates the owner of any expressions to be typed in the context
    *  if that owner is different from the context's owner. Typically, a context with a class