Add test of pickling positions under -Ytest-pickler

Author: OlivierBlanvillain

src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -164,7 +164,6 @@ class ScalaSettings extends Settings.SettingGroup {
   val YforceSbtPhases = BooleanSetting("-Yforce-sbt-phases", "Run the phases used by sbt for incremental compilation (ExtractDependencies and ExtractAPI) even if the compiler is ran outside of sbt, for debugging.")
   val YdumpSbtInc = BooleanSetting("-Ydump-sbt-inc", "For every compiled foo.scala, output the API representation and dependencies used for sbt incremental compilation in foo.inc, implies -Yforce-sbt-phases.")
   val YcheckAllPatmat = BooleanSetting("-Ycheck-all-patmat", "Check exhaustivity and redundancy of all pattern matching (used for testing the algorithm)")
-  def stop = YstopAfter
 
   /** Area-specific debug output.
    */

src/dotty/tools/dotc/core/Phases.scala

@@ -79,8 +79,13 @@ object Phases {
       * Each TreeTransform gets own period,
       * whereas a combined TreeTransformer gets period equal to union of periods of it's TreeTransforms
       */
-    def squashPhases(phasess: List[List[Phase]],
-                             phasesToSkip: List[String], stopBeforePhases: List[String], stopAfterPhases: List[String], YCheckAfter: List[String]): List[Phase] = {
+    def squashPhases(
+      phasess: List[List[Phase]],
+      phasesToSkip: List[String],
+      stopBeforePhases: List[String],
+      stopAfterPhases: List[String],
+      YCheckAfter: List[String]
+    ): List[Phase] = {
       val squashedPhases = ListBuffer[Phase]()
       var prevPhases: Set[Class[_ <: Phase]] = Set.empty
       val YCheckAll = YCheckAfter.contains("all")

src/dotty/tools/dotc/transform/Pickler.scala

@@ -12,6 +12,7 @@ import Phases._
 import Symbols._
 import Flags.Module
 import collection.mutable
+import util.Positions.Position
 
 /** This phase pickles trees */
 class Pickler extends Phase {
@@ -25,7 +26,7 @@ class Pickler extends Phase {
     s.close
   }
 
-  private val beforePickling = new mutable.HashMap[ClassSymbol, String]
+  private val beforePickling = new mutable.HashMap[ClassSymbol, (String, Position)]
 
   /** Drop any elements of this list that are linked module classes of other elements in the list */
   private def dropCompanionModuleClasses(clss: List[ClassSymbol])(implicit ctx: Context): List[ClassSymbol] = {
@@ -40,7 +41,7 @@ class Pickler extends Phase {
 
     for { cls <- dropCompanionModuleClasses(topLevelClasses(unit.tpdTree))
           tree <- sliceTopLevel(unit.tpdTree, cls) } {
-      if (ctx.settings.YtestPickler.value) beforePickling(cls) = tree.show
+      if (ctx.settings.YtestPickler.value) beforePickling(cls) = (tree.show, tree.pos)
       val pickler = new TastyPickler()
       unit.picklers += (cls -> pickler)
       val treePkl = pickler.treePkl
@@ -73,25 +74,34 @@ class Pickler extends Phase {
   private def testUnpickler(units: List[CompilationUnit])(implicit ctx: Context): Unit = {
     pickling.println(i"testing unpickler at run ${ctx.runId}")
     ctx.initialize()
-    val unpicklers =
+    val unpicklers: List[(ClassSymbol, DottyUnpickler)] =
       for (unit <- units; (cls, pickler) <- unit.picklers) yield {
         val unpickler = new DottyUnpickler(pickler.assembleParts())
         unpickler.enter(roots = Set())
         cls -> unpickler
       }
-    pickling.println("************* entered toplevel ***********")
+    pickling.println("*********** Entered toplevel ***********")
     for ((cls, unpickler) <- unpicklers) {
-      val unpickled = unpickler.body(ctx.addMode(Mode.ReadPositions))
-      testSame(i"$unpickled%\n%", beforePickling(cls), cls)
+      val ((unpickled: Tree) :: Nil) = unpickler.body(ctx.addMode(Mode.ReadPositions))
+      val (beforeShow, beforePos) = beforePickling(cls)
+      testSameShow(unpickled.show, beforeShow, cls)
+      testSamePos(unpickled.pos, beforePos, cls)
     }
   }
 
-  private def testSame(unpickled: String, previous: String, cls: ClassSymbol)(implicit ctx: Context) =
+  private def testSameShow(unpickled: String, previous: String, cls: ClassSymbol)(implicit ctx: Context): Unit =
     if (previous != unpickled) {
       output("before-pickling.txt", previous)
       output("after-pickling.txt", unpickled)
       ctx.error(i"""pickling difference for ${cls.fullName} in ${cls.sourceFile}, for details:
                    |
                    |  diff before-pickling.txt after-pickling.txt""")
     }
+
+  // Ignoring Position#point which are not pickled.
+  private def testSamePos(unpickled: Position, previous: Position, cls: ClassSymbol)(implicit ctx: Context): Unit =
+    if (unpickled.start != previous.start || unpickled.end != previous.end) {
+      ctx.error(i"""pickling difference in ${cls.fullName} in ${cls.sourceFile} positions:
+                   |previous positions $previous unpickled as $unpickled""")
+    }
 }

src/dotty/tools/dotc/util/Positions.scala

@@ -12,7 +12,7 @@ import language.implicitConversions
 object Positions {
 
   private val StartEndBits = 26
-   val StartEndMask: Long = (1L << StartEndBits) - 1
+  val StartEndMask: Long = (1L << StartEndBits) - 1
   private val SyntheticPointDelta = (1 << (64 - StartEndBits * 2)) - 1
 
   /** The maximal representable offset in a position */