Fixes to synchronize the position of trees and symbols

Various changes so that `testPickling` with `-Yprintpos-syms` now passes.

It's not always obvious what position to use when new trees are created,
here are the principles we used here:
- When a definition tree is replaced by another definition tree (for
  example, in `ParamForwarding`), the new tree position is set to the
  old tree position.
- When a reference tree is replaced by a definition tree representing an
  accessor and a new reference tree that calls the accessor (for example
  in `SuperAccessors`), the accessor position is set to the old
  tree *point*, and the new reference tree position is set to the old
  tree *position*. This makes sense because we already use zero-extent
  positions for compiler artifacts that the IDE should ignore and an
  accessor is a compilation artifact.

Author: smarter

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

@@ -196,7 +196,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       case tp: MethodType =>
         def valueParam(name: TermName, info: Type): TermSymbol = {
           val maybeImplicit = if (tp.isImplicitMethod) Implicit else EmptyFlags
-          ctx.newSymbol(sym, name, TermParam | maybeImplicit, info)
+          ctx.newSymbol(sym, name, TermParam | maybeImplicit, info, coord = sym.coord)
         }
         val params = (tp.paramNames, tp.paramInfos).zipped.map(valueParam)
         val (paramss, rtp) = valueParamss(tp.instantiate(params map (_.termRef)))

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

@@ -288,7 +288,7 @@ trait Symbols { this: Context =>
     val tparamBuf = new mutable.ListBuffer[TypeSymbol]
     val trefBuf = new mutable.ListBuffer[TypeRef]
     for (name <- names) {
-      val tparam = newNakedSymbol[TypeName](NoCoord)
+      val tparam = newNakedSymbol[TypeName](owner.coord)
       tparamBuf += tparam
       trefBuf += TypeRef(owner.thisType, tparam)
     }

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

@@ -70,7 +70,7 @@ class ParamForwarding(thisPhase: DenotTransformer) {
                     val superAcc =
                       Super(This(currentClass), tpnme.EMPTY, inConstrCall = false).select(alias)
                     typr.println(i"adding param forwarder $superAcc")
-                    DefDef(sym, superAcc.ensureConforms(sym.info.widen))
+                    DefDef(sym, superAcc.ensureConforms(sym.info.widen)).withPos(stat.pos)
                   }
                   return forwarder(ctx.withPhase(thisPhase.next))
                 }

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

@@ -76,18 +76,19 @@ class SuperAccessors(thisPhase: DenotTransformer) {
       if (clazz is Trait) superName = superName.expandedName(clazz)
       val superInfo = sel.tpe.widenSingleton.ensureMethodic
 
+      val accPos = sel.pos.focus
       val superAcc = clazz.info.decl(superName)
         .suchThat(_.signature == superInfo.signature).symbol
         .orElse {
           ctx.debuglog(s"add super acc ${sym.showLocated} to $clazz")
           val deferredOrPrivate = if (clazz is Trait) Deferred else Private
           val acc = ctx.newSymbol(
               clazz, superName, Artifact | Method | deferredOrPrivate,
-              superInfo, coord = sym.coord).enteredAfter(thisPhase)
+              superInfo, coord = accPos).enteredAfter(thisPhase)
           // Diagnostic for SI-7091
           if (!accDefs.contains(clazz))
             ctx.error(s"Internal error: unable to store accessor definition in ${clazz}. clazz.hasPackageFlag=${clazz is Package}. Accessor required for ${sel} (${sel.show})", sel.pos)
-          else accDefs(clazz) += DefDef(acc, EmptyTree)
+          else accDefs(clazz) += DefDef(acc, EmptyTree).withPos(accPos)
           acc
         }
 
@@ -181,13 +182,14 @@ class SuperAccessors(thisPhase: DenotTransformer) {
         }
         accTypeOf(sym.info)
       }
+      val accPos = sel.pos.focus
       val protectedAccessor = clazz.info.decl(accName).suchThat(_.signature == accType.signature).symbol orElse {
         val newAcc = ctx.newSymbol(
-          clazz, accName, Artifact | Method, accType, coord = sel.pos).enteredAfter(thisPhase)
+          clazz, accName, Artifact | Method, accType, coord = accPos).enteredAfter(thisPhase)
         val code = polyDefDef(newAcc, trefs => vrefss => {
           val (receiver :: _) :: tail = vrefss
           val base = receiver.select(sym).appliedToTypes(trefs)
-          (base /: tail)(Apply(_, _))
+          (base /: tail)(Apply(_, _)).withPos(accPos)
         })
         ctx.debuglog("created protected accessor: " + code)
         accDefs(clazz) += code
@@ -233,13 +235,14 @@ class SuperAccessors(thisPhase: DenotTransformer) {
           MethodType(receiverType :: Nil)(mt => tpe.substThis(sym.owner.asClass, mt.newParamRef(0)))
       }
       val accType = accTypeOf(sym.info)
+      val accPos = tree.pos.focus
       val protectedAccessor = clazz.info.decl(accName).suchThat(_.signature == accType.signature).symbol orElse {
         val newAcc = ctx.newSymbol(
-            clazz, accName, Artifact, accType, coord = tree.pos).enteredAfter(thisPhase)
+            clazz, accName, Artifact, accType, coord = accPos).enteredAfter(thisPhase)
         val code = polyDefDef(newAcc, trefs => vrefss => {
           val (receiver :: _) :: tail = vrefss
           val base = receiver.select(sym).appliedToTypes(trefs)
-          (base /: vrefss)(Apply(_, _))
+          (base /: vrefss)(Apply(_, _)).withPos(accPos)
         })
         ctx.debuglog("created protected accessor: " + code)
         accDefs(clazz) += code
@@ -265,12 +268,13 @@ class SuperAccessors(thisPhase: DenotTransformer) {
 
       val accName = ProtectedSetterName(field.name)
       val accType = MethodType(clazz.classInfo.selfType :: field.info :: Nil, defn.UnitType)
+      val accPos = tree.pos.focus
       val protectedAccessor = clazz.info.decl(accName).symbol orElse {
         val newAcc = ctx.newSymbol(
-            clazz, accName, Artifact, accType, coord = tree.pos).enteredAfter(thisPhase)
+            clazz, accName, Artifact, accType, coord = accPos).enteredAfter(thisPhase)
         val code = DefDef(newAcc, vrefss => {
           val (receiver :: value :: Nil) :: Nil = vrefss
-          Assign(receiver.select(field), value).withPos(tree.pos)
+          Assign(receiver.select(field), value).withPos(accPos)
         })
         ctx.debuglog("created protected setter: " + code)
         accDefs(clazz) += code

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

@@ -99,7 +99,7 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
         case nme.productElement => vrefss => productElementBody(accessors.length, vrefss.head.head)
       }
       ctx.log(s"adding $synthetic to $clazz at ${ctx.phase}")
-      DefDef(synthetic, syntheticRHS(ctx.withOwner(synthetic)))
+      DefDef(synthetic, syntheticRHS(ctx.withOwner(synthetic))).withPos(ctx.owner.pos.focus)
     }
 
     /** The class

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

@@ -28,8 +28,8 @@ object EtaExpansion {
       val name = UniqueName.fresh(prefix)
       val liftedType = fullyDefinedType(expr.tpe.widen, "lifted expression", expr.pos)
       val sym = ctx.newSymbol(ctx.owner, name, EmptyFlags, liftedType, coord = positionCoord(expr.pos))
-      defs += ValDef(sym, expr)
-      ref(sym.termRef)
+      defs += ValDef(sym, expr).withPos(expr.pos.focus)
+      ref(sym.termRef).withPos(expr.pos)
     }
 
   /** Lift out common part of lhs tree taking part in an operator assignment such as

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

@@ -98,8 +98,8 @@ object Inliner {
             val accessorType = accessedType.ensureMethodic
             val accessor = accessorSymbol(tree, accessorType).asTerm
             val accessorDef = polyDefDef(accessor, tps => argss =>
-              rhs(refPart, tps, argss))
-            val accessorRef = ref(accessor).appliedToTypeTrees(targs).appliedToArgss(argss)
+              rhs(refPart, tps, argss).withPos(tree.pos.focus))
+            val accessorRef = ref(accessor).appliedToTypeTrees(targs).appliedToArgss(argss).withPos(tree.pos)
             (accessorDef, accessorRef)
           } else {
             // Hard case: Reference needs to go via a dynamic prefix
@@ -135,11 +135,14 @@ object Inliner {
             val accessor = accessorSymbol(tree, accessorType).asTerm
 
             val accessorDef = polyDefDef(accessor, tps => argss =>
-              rhs(argss.head.head.select(refPart.symbol), tps.drop(localRefs.length), argss.tail))
+              rhs(argss.head.head.select(refPart.symbol), tps.drop(localRefs.length), argss.tail)
+              .withPos(tree.pos.focus)
+            )
 
             val accessorRef = ref(accessor)
               .appliedToTypeTrees(localRefs.map(TypeTree(_)) ++ targs)
               .appliedToArgss((qual :: Nil) :: argss)
+              .withPos(tree.pos)
             (accessorDef, accessorRef)
           }
         accessors += accessorDef
@@ -168,8 +171,8 @@ object Inliner {
               // Draft code (incomplete):
               //
               //  val accessor = accessorSymbol(tree, TypeAlias(tree.tpe)).asType
-              //  myAccessors += TypeDef(accessor)
-              //  ref(accessor)
+              //  myAccessors += TypeDef(accessor).withPos(tree.pos.focus)
+              //  ref(accessor).withPos(tree.pos)
               //
               tree
             }