Reverted [19310] ...

4 files changed, 71 insertions, 64 deletions

diff --git a/src/compiler/scala/tools/nsc/dependencies/DependencyAnalysis.scala b/src/compiler/scala/tools/nsc/dependencies/DependencyAnalysis.scala
index cbf5d5b2dc..4b19238b7e 100644
--- a/src/compiler/scala/tools/nsc/dependencies/DependencyAnalysis.scala
+++ b/src/compiler/scala/tools/nsc/dependencies/DependencyAnalysis.scala
@@ -141,9 +141,10 @@ trait DependencyAnalysis extends SubComponent with Files {
             references += file -> (references(file) + tree.symbol.fullNameString)
           }
           tree match {
-            case cdef: ClassDef if !cdef.symbol.hasFlag(Flags.PACKAGE) =>
+            case cdef: ClassDef if !cdef.symbol.isModuleClass && !cdef.symbol.hasFlag(Flags.PACKAGE) =>
               buf += cdef.symbol
               super.traverse(tree)
+
             case _ =>
               super.traverse(tree)
           }
diff --git a/src/compiler/scala/tools/nsc/interactive/RefinedBuildManager.scala b/src/compiler/scala/tools/nsc/interactive/RefinedBuildManager.scala
index 9d0f6953c4..10e57df076 100644
--- a/src/compiler/scala/tools/nsc/interactive/RefinedBuildManager.scala
+++ b/src/compiler/scala/tools/nsc/interactive/RefinedBuildManager.scala
@@ -23,7 +23,10 @@ import io.AbstractFile
  */
 class RefinedBuildManager(val settings: Settings) extends Changes with BuildManager {
 
-  class BuilderGlobal(settings: Settings) extends scala.tools.nsc.Global(settings)  {
+  class BuilderGlobal(settings: Settings, reporter : Reporter) extends scala.tools.nsc.Global(settings, reporter)  {
+
+    def this(settings: Settings) =
+      this(settings, new ConsoleReporter(settings))
 
     override def computeInternalPhases() {
       super.computeInternalPhases
@@ -95,28 +98,19 @@ class RefinedBuildManager(val settings: Settings) extends Changes with BuildMana
     }
 
     val changesOf = new mutable.HashMap[Symbol, List[Change]]
-    val additionalDefs: mutable.HashSet[AbstractFile] = mutable.HashSet.empty
+
     val defs = compiler.dependencyAnalysis.definitions
-    for (src <- files) {
-        if (definitions(src).isEmpty)
-            additionalDefs ++= compiler.dependencyAnalysis.
-                                dependencies.dependentFiles(1, mutable.Set(src))
-        else {
-            val syms = defs(src)
-            for (sym <- syms) {
-            	definitions(src).find(_.fullNameString == sym.fullNameString) match {
-                case Some(oldSym) =>
-                    changesOf(oldSym) = changeSet(oldSym, sym)
-                case _ =>
-                    // a new top level definition, no need to process
-                }
-            }
-        }
+    for (src <- files; val syms = defs(src); sym <- syms) {
+      definitions(src).find(_.fullNameString == sym.fullNameString) match {
+        case Some(oldSym) =>
+          changesOf(oldSym) = changeSet(oldSym, sym)
+        case _ =>
+          // a new top level definition, no need to process
+      }
     }
-
     println("Changes: " + changesOf)
     updateDefinitions(files)
-    update(invalidated(files, changesOf) ++ additionalDefs)
+    update(invalidated(files, changesOf))
   }
 
   /** Return the set of source files that are invalidated by the given changes. */
@@ -133,60 +127,67 @@ class RefinedBuildManager(val settings: Settings) extends Changes with BuildMana
       break
     }
 
-    for ((oldSym, changes) <- changesOf; change <- changes) {
-      def checkParents(cls: Symbol, file: AbstractFile) {
-        val parentChange = cls.info.parents.exists(_.typeSymbol.fullNameString == oldSym.fullNameString)
-//         println("checkParents " + cls + " oldSym: " + oldSym + " parentChange: " + parentChange + " " + cls.info.parents)
-        change match {
-          case Changed(Class(_)) if parentChange =>
-            invalidate(file, "parents have changed", change)
+    // changesOf will be empty just after initialization with a saved
+    // dependencies file.
+    if (changesOf.isEmpty)
+      buf ++= directDeps
+    else {
+      for ((oldSym, changes) <- changesOf; change <- changes) {
+
+        def checkParents(cls: Symbol, file: AbstractFile) {
+          val parentChange = cls.info.parents.exists(_.typeSymbol.fullNameString == oldSym.fullNameString)
+//          println("checkParents " + cls + " oldSym: " + oldSym + " parentChange: " + parentChange + " " + cls.info.parents)
+          change match {
+            case Changed(Class(_)) if parentChange =>
+              invalidate(file, "parents have changed", change)
 
-          case Added(Definition(_)) if parentChange =>
-            invalidate(file, "inherited new method", change)
+            case Added(Definition(_)) if parentChange =>
+              invalidate(file, "inherited new method", change)
 
-          case Removed(Definition(_)) if parentChange =>
-            invalidate(file, "inherited method removed", change)
+            case Removed(Definition(_)) if parentChange =>
+              invalidate(file, "inherited method removed", change)
 
-          case _ => ()
+            case _ => ()
+          }
         }
-      }
 
-      def checkInterface(cls: Symbol, file: AbstractFile) {
-        change match {
-          case Added(Definition(name)) =>
-            if (cls.info.decls.iterator.exists(_.fullNameString == name))
-              invalidate(file, "of new method with existing name", change)
-          case Changed(Class(name)) =>
-            if (cls.info.typeSymbol.fullNameString == name)
-              invalidate(file, "self type changed", change)
-          case _ =>
-            ()
+        def checkInterface(cls: Symbol, file: AbstractFile) {
+          change match {
+            case Added(Definition(name)) =>
+              if (cls.info.decls.iterator.exists(_.fullNameString == name))
+                invalidate(file, "of new method with existing name", change)
+            case Changed(Class(name)) =>
+              if (cls.info.typeSymbol.fullNameString == name)
+                invalidate(file, "self type changed", change)
+            case _ =>
+              ()
+          }
         }
-      }
 
-      def checkReferences(file: AbstractFile) {
+        def checkReferences(file: AbstractFile) {
 //          println(file + ":" + references(file))
-        val refs = references(file)
-        if (refs.isEmpty)
-          invalidate(file, "it is a direct dependency and we don't yet have finer-grained dependency information", change)
-        else {
-          change match {
-            case Removed(Definition(name)) if refs(name) =>
-              invalidate(file, "it references deleted definition", change)
-            case Removed(Class(name)) if (refs(name)) =>
-              invalidate(file, "it references deleted class", change)
-            case Changed(Definition(name)) if (refs(name)) =>
-              invalidate(file, "it references changed definition", change)
-            case _ => ()
+          val refs = references(file)
+          if (refs.isEmpty)
+            invalidate(file, "it is a direct dependency and we don't yet have finer-grained dependency information", change)
+          else {
+            change match {
+              case Removed(Definition(name)) if refs(name) =>
+                invalidate(file, "it references deleted definition", change)
+              case Removed(Class(name)) if (refs(name)) =>
+                invalidate(file, "it references deleted class", change)
+              case Changed(Definition(name)) if (refs(name)) =>
+                invalidate(file, "it references changed definition", change)
+              case _ => ()
+            }
           }
         }
-      }
 
-      breakable {
-        for (file <- directDeps) {
-          for (cls <- definitions(file)) checkParents(cls, file)
-          for (cls <- definitions(file)) checkInterface(cls, file)
-          checkReferences(file)
+        breakable {
+          for (file <- directDeps) {
+            for (cls <- definitions(file)) checkParents(cls, file)
+            for (cls <- definitions(file)) checkInterface(cls, file)
+            checkReferences(file)
+          }
         }
       }
     }
diff --git a/src/compiler/scala/tools/nsc/interactive/SimpleBuildManager.scala b/src/compiler/scala/tools/nsc/interactive/SimpleBuildManager.scala
index f5bd254c72..2805bcf6ee 100644
--- a/src/compiler/scala/tools/nsc/interactive/SimpleBuildManager.scala
+++ b/src/compiler/scala/tools/nsc/interactive/SimpleBuildManager.scala
@@ -18,7 +18,11 @@ import io.AbstractFile
  */
 class SimpleBuildManager(val settings: Settings) extends BuildManager {
 
-  class BuilderGlobal(settings: Settings) extends scala.tools.nsc.Global(settings)  {
+  class BuilderGlobal(settings: Settings, reporter : Reporter) extends scala.tools.nsc.Global(settings, reporter)  {
+
+    def this(settings: Settings) =
+      this(settings, new ConsoleReporter(settings))
+
     def newRun() = new Run()
   }
 
diff --git a/src/compiler/scala/tools/nsc/symtab/Symbols.scala b/src/compiler/scala/tools/nsc/symtab/Symbols.scala
index 9293ab4c3f..9f31795c14 100644
--- a/src/compiler/scala/tools/nsc/symtab/Symbols.scala
+++ b/src/compiler/scala/tools/nsc/symtab/Symbols.scala
@@ -1888,6 +1888,7 @@ trait Symbols {
     }
 
     override def cloneSymbolImpl(owner: Symbol): Symbol = {
+      assert(!isModuleClass)
       val clone = new ClassSymbol(owner, pos, name)
       if (thisSym != this) {
         clone.typeOfThis = typeOfThis