Fix Symbol#isDefinedInCurrentRun

And add a test to make sure it's working. The rest required a change to
the testing infrastructure: files in compilation groups should be sorted
alphabetically, otherwise we cannot know in advance if the error will
happen in A1.scala or A2.scala

Author: smarter

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

@@ -10,23 +10,23 @@ import Types._
 import Scopes._
 import typer.{FrontEnd, Typer, ImportInfo, RefChecks}
 import Decorators._
-import io.PlainFile
+import io.{AbstractFile, PlainFile}
 import scala.io.Codec
-import util._
+import util.{Set => _, _}
 import reporting.Reporter
 import transform.TreeChecker
 import rewrite.Rewrites
 import java.io.{BufferedWriter, OutputStreamWriter}
 import printing.XprintMode
+import typer.ImplicitRunInfo
 
 import scala.annotation.tailrec
 import dotty.tools.io.VirtualFile
 import scala.util.control.NonFatal
 
 /** A compiler run. Exports various methods to compile source files */
 class Run(comp: Compiler, ictx: Context) {
-
-  var units: List[CompilationUnit] = _
+  import Run._
 
   /** Produces the following contexts, from outermost to innermost
    *
@@ -78,7 +78,7 @@ class Run(comp: Compiler, ictx: Context) {
     compileSources(sources)
   } catch {
     case NonFatal(ex) =>
-      ctx.echo(i"exception occurred while compiling $units%, %")
+      ctx.echo(i"exception occurred while compiling ${ctx.runInfo.units}%, %")
       throw ex
   }
 
@@ -90,17 +90,17 @@ class Run(comp: Compiler, ictx: Context) {
    */
   def compileSources(sources: List[SourceFile]) =
     if (sources forall (_.exists)) {
-      units = sources map (new CompilationUnit(_))
+      ctx.runInfo.units = sources map (new CompilationUnit(_))
       compileUnits()
     }
 
   def compileUnits(us: List[CompilationUnit]): Unit = {
-    units = us
+    ctx.runInfo.units = us
     compileUnits()
   }
 
   def compileUnits(us: List[CompilationUnit], ctx: Context): Unit = {
-    units = us
+    ctx.runInfo.units = us
     compileUnits()(ctx)
   }
 
@@ -122,16 +122,16 @@ class Run(comp: Compiler, ictx: Context) {
         if (phase.isRunnable)
           Stats.trackTime(s"$phase ms ") {
             val start = System.currentTimeMillis
-            units = phase.runOn(units)
+            ctx.runInfo.units = phase.runOn(ctx.runInfo.units)
             if (ctx.settings.Xprint.value.containsPhase(phase)) {
-              for (unit <- units) {
+              for (unit <- ctx.runInfo.units) {
                 lastPrintedTree =
                   printTree(lastPrintedTree)(ctx.fresh.setPhase(phase.next).setCompilationUnit(unit))
               }
             }
             ctx.informTime(s"$phase ", start)
             Stats.record(s"total trees at end of $phase", ast.Trees.ntrees)
-            for (unit <- units)
+            for (unit <- ctx.runInfo.units)
               Stats.record(s"retained typed trees at end of $phase", unit.tpdTree.treeSize)
           }
     }
@@ -191,3 +191,35 @@ class Run(comp: Compiler, ictx: Context) {
     r
   }
 }
+
+object Run {
+  /** Info that changes on each compiler run */
+  class RunInfo(initctx: Context) extends ImplicitRunInfo with ConstraintRunInfo {
+    implicit val ctx: Context = initctx
+
+    private[this] var myUnits: List[CompilationUnit] = _
+    private[this] var myUnitsCached: List[CompilationUnit] = _
+    private[this] var myFiles: Set[AbstractFile] = _
+
+    /** The compilation units currently being compiled, this may return different
+     *  results over time.
+     */
+    def units: List[CompilationUnit] = myUnits
+
+    private[Run] def units_=(us: List[CompilationUnit]): Unit =
+      myUnits = us
+
+
+    /** The files currently being compiled, this may return different results over time.
+     *  These files do not have to be source files since it's possible to compile
+     *  from TASTY.
+     */
+    def files: Set[AbstractFile] = {
+      if (myUnits ne myUnitsCached) {
+        myUnitsCached = myUnits
+        myFiles = myUnits.map(_.source.file).toSet
+      }
+      myFiles
+    }
+  }
+}

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

@@ -2,6 +2,7 @@ package dotty.tools.dotc
 package core
 
 import Contexts._
+import Run.RunInfo
 import config.Printers.typr
 
 trait ConstraintRunInfo { self: RunInfo =>

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

@@ -14,11 +14,12 @@ import NameOps._
 import Uniques._
 import SymDenotations._
 import Comments._
+import Run.RunInfo
 import util.Positions._
 import ast.Trees._
 import ast.untpd
 import util.{FreshNameCreator, SimpleIdentityMap, SourceFile, NoSource}
-import typer.{Implicits, ImplicitRunInfo, ImportInfo, Inliner, NamerContextOps, SearchHistory, TypeAssigner, Typer}
+import typer.{Implicits, ImportInfo, Inliner, NamerContextOps, SearchHistory, TypeAssigner, Typer}
 import Implicits.ContextualImplicits
 import config.Settings._
 import config.Config
@@ -675,11 +676,6 @@ object Contexts {
     // @sharable val theBase = new ContextBase // !!! DEBUG, so that we can use a minimal context for reporting even in code that normally cannot access a context
   }
 
-  /** Info that changes on each compiler run */
-  class RunInfo(initctx: Context) extends ImplicitRunInfo with ConstraintRunInfo {
-    implicit val ctx: Context = initctx
-  }
-
   class GADTMap(initBounds: SimpleIdentityMap[Symbol, TypeBounds]) extends util.DotClass {
     private[this] var myBounds = initBounds
     def setBounds(sym: Symbol, b: TypeBounds): Unit =

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

@@ -440,10 +440,11 @@ object Symbols {
       if (lastDenot == null) NoRunId else lastDenot.validFor.runId
 
     /** Does this symbol come from a currently compiled source file? */
-    final def isDefinedInCurrentRun(implicit ctx: Context): Boolean = {
-      // FIXME: broken now now that symbols unpickled from TASTY have a position
-      pos.exists && defRunId == ctx.runId
-    }
+    final def isDefinedInCurrentRun(implicit ctx: Context): Boolean =
+      pos.exists && defRunId == ctx.runId && {
+        val file = associatedFile
+        file != null && ctx.runInfo.files.contains(file)
+      }
 
     final def isValidInCurrentRun(implicit ctx: Context): Boolean =
       lastDenot.validFor.runId == ctx.runId || ctx.stillValid(lastDenot)
@@ -540,7 +541,7 @@ object Symbols {
      *  Overridden in ClassSymbol
      */
     def associatedFile(implicit ctx: Context): AbstractFile =
-      denot.topLevelClass.symbol.associatedFile
+      if (lastDenot == null) null else lastDenot.topLevelClass.symbol.associatedFile
 
     /** The class file from which this class was generated, null if not applicable. */
     final def binaryFile(implicit ctx: Context): AbstractFile = {

compiler/src/dotty/tools/dotc/fromtasty/TASTYRun.scala

@@ -6,7 +6,7 @@ import core.Contexts._
 
 class TASTYRun(comp: Compiler, ictx: Context) extends Run(comp, ictx) {
   override def compile(classNames: List[String]) = {
-    units = classNames.map(new TASTYCompilationUnit(_))
-    compileUnits()
+    val units = classNames.map(new TASTYCompilationUnit(_))
+    compileUnits(units)
   }
 }

compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala

@@ -226,7 +226,7 @@ class InteractiveDriver(settings: List[String]) extends Driver {
 
       run.compileSources(List(source))
       run.printSummary()
-      val t = run.units.head.tpdTree
+      val t = ctx.runInfo.units.head.tpdTree
       cleanup(t)
       myOpenedTrees(uri) = topLevelClassTrees(t, source)
 

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

@@ -9,6 +9,7 @@ import util.Stats.{track, record, monitored}
 import printing.{Showable, Printer}
 import printing.Texts._
 import Contexts._
+import Run.RunInfo
 import Types._
 import Flags._
 import TypeErasure.{erasure, hasStableErasure}

compiler/test/dotty/tools/dotc/CompilerTest.scala

@@ -104,7 +104,7 @@ abstract class CompilerTest {
           else (fp, jfp)
         }
       val expErrors = expectedErrors(filePaths.toList)
-      (filePaths, javaFilePaths, normArgs, expErrors)
+      (filePaths.sorted, javaFilePaths.sorted, normArgs, expErrors)
     }
     if (runTest)
       log(s"WARNING: run tests can only be run by partest, JUnit just verifies compilation: $prefix$dirName")

compiler/test/dotty/tools/vulpix/ParallelTesting.scala

@@ -151,7 +151,8 @@ trait ParallelTesting extends RunnerOrchestration { self =>
   ) extends TestSource {
 
     /** Get the files grouped by `_X` as a list of groups, files missing this
-     *  suffix will be put into the same group
+     *  suffix will be put into the same group.
+     *  Files in each group are sorted alphabetically.
      *
      *  Filters out all none source files
      */
@@ -170,7 +171,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
         .toOption
         .getOrElse("")
       }
-      .toList.sortBy(_._1).map(_._2.filter(isSourceFile))
+      .toList.sortBy(_._1).map(_._2.filter(isSourceFile).sorted)
   }
 
   /** Each `Test` takes the `testSources` and performs the compilation and assertions

tests/neg/checkNoConflict/A1.scala

@@ -0,0 +1,2 @@
+package foo
+class A

tests/neg/checkNoConflict/A2.scala

@@ -0,0 +1,2 @@
+package foo
+class A // error: class A in package foo has already been compiled once during this run