Moved some pure string manipulation functions o...

Moved some pure string manipulation functions out of the base class
for all Reporters and into a more suitable home. "Please, help stamp
out inheritance abuse. If you won't do it for yourself do it for your
children... or your subclass's children." Also removed some dead
reporter code (not used anywhere, including the IDE.) No review.

10 files changed, 92 insertions, 120 deletions

diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala
index c98562f1f0..0f5be1791b 100644
--- a/src/compiler/scala/tools/nsc/Global.scala
+++ b/src/compiler/scala/tools/nsc/Global.scala
@@ -338,7 +338,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) extends Symb
         currentRun.currentUnit = unit
         if (!cancelled(unit)) {
           currentRun.informUnitStarting(this, unit)
-          reporter.withSource(unit.source) { apply(unit) }
+          apply(unit)
         }
         currentRun.advanceUnit
       } finally {
@@ -1066,9 +1066,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) extends Symb
       def loop(ph: Phase) {
         if (stop(ph)) refreshProgress
         else {
-          reporter.withSource(unit.source) {
-            atPhase(ph)(ph.asInstanceOf[GlobalPhase] applyPhase unit)
-          }
+          atPhase(ph)(ph.asInstanceOf[GlobalPhase] applyPhase unit)
           loop(ph.next match {
             case `ph`   => null   // ph == ph.next implies terminal, and null ends processing
             case x      => x
diff --git a/src/compiler/scala/tools/nsc/ast/parser/SyntaxAnalyzer.scala b/src/compiler/scala/tools/nsc/ast/parser/SyntaxAnalyzer.scala
index 88b998f1ac..b5ec0ceffb 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/SyntaxAnalyzer.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/SyntaxAnalyzer.scala
@@ -21,12 +21,15 @@ abstract class SyntaxAnalyzer extends SubComponent with Parsers with MarkupParse
     override val keepsTypeParams = false
 
     def apply(unit: global.CompilationUnit) {
-      global.informProgress("parsing " + unit)
+      import global._
+      informProgress("parsing " + unit)
       unit.body =
         if (unit.source.file.name.endsWith(".java")) new JavaUnitParser(unit).parse()
-        else if (!global.reporter.incompleteHandled) new UnitParser(unit).smartParse()
-        else new UnitParser(unit).parse()
-      if (global.settings.Yrangepos.value && !global.reporter.hasErrors) global.validatePositions(unit.body)
+        else if (reporter.incompleteHandled) new UnitParser(unit).parse()
+        else new UnitParser(unit).smartParse()
+
+      if (settings.Yrangepos.value && !reporter.hasErrors)
+        validatePositions(unit.body)
     }
   }
 }
diff --git a/src/compiler/scala/tools/nsc/interactive/Global.scala b/src/compiler/scala/tools/nsc/interactive/Global.scala
index 694df32e32..af5b9a9882 100644
--- a/src/compiler/scala/tools/nsc/interactive/Global.scala
+++ b/src/compiler/scala/tools/nsc/interactive/Global.scala
@@ -942,10 +942,7 @@ class Global(settings: Settings, reporter: Reporter, projectName: String = "")
      *  @return true iff typechecked correctly
      */
     private def applyPhase(phase: Phase, unit: CompilationUnit) {
-      val oldSource = reporter.getSource
-      reporter.withSource(unit.source) {
-        atPhase(phase) { phase.asInstanceOf[GlobalPhase] applyPhase unit }
-      }
+      atPhase(phase) { phase.asInstanceOf[GlobalPhase] applyPhase unit }
     }
   }
 
diff --git a/src/compiler/scala/tools/nsc/reporters/AbstractReporter.scala b/src/compiler/scala/tools/nsc/reporters/AbstractReporter.scala
index 7d2c0fe424..49d23b1ab3 100644
--- a/src/compiler/scala/tools/nsc/reporters/AbstractReporter.scala
+++ b/src/compiler/scala/tools/nsc/reporters/AbstractReporter.scala
@@ -14,6 +14,10 @@ import scala.tools.nsc.util.Position
  * This reporter implements filtering.
  */
 abstract class AbstractReporter extends Reporter {
+  val settings: Settings
+  def display(pos: Position, msg: String, severity: Severity): Unit
+  def displayPrompt(): Unit
+
   private val positions = new HashMap[Position, Severity]
 
   override def reset() {
@@ -21,14 +25,10 @@ abstract class AbstractReporter extends Reporter {
     positions.clear
   }
 
-  val settings: Settings
   private def isVerbose   = settings.verbose.value
   private def noWarnings  = settings.nowarnings.value
   private def isPromptSet = settings.prompt.value
 
-  def display(pos: Position, msg: String, severity: Severity): Unit
-  def displayPrompt(): Unit
-
   protected def info0(pos: Position, msg: String, _severity: Severity, force: Boolean) {
     val severity =
       if (settings.Xwarnfatal.value && _severity == WARNING) ERROR
diff --git a/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala b/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala
index 75c25afa5b..a6e661c4b4 100644
--- a/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala
+++ b/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala
@@ -6,14 +6,17 @@
 package scala.tools.nsc
 package reporters
 
-import java.io.{BufferedReader, InputStreamReader, IOException, PrintWriter}
+import java.io.{ BufferedReader, IOException, PrintWriter }
 import util._
+import scala.tools.util.StringOps.countElementsAsString
 
 /**
  * This class implements a Reporter that displays messages on a text
  * console.
  */
 class ConsoleReporter(val settings: Settings, reader: BufferedReader, writer: PrintWriter) extends AbstractReporter {
+  def this(settings: Settings) = this(settings, Console.in, new PrintWriter(Console.err, true))
+
   /** Whether a short file name should be displayed before errors */
   var shortname: Boolean = false
 
@@ -31,9 +34,6 @@ class ConsoleReporter(val settings: Settings, reader: BufferedReader, writer: Pr
     if (label0 eq null) "" else label0 + ": "
   }
 
-  def this(settings: Settings) =
-    this(settings, Console.in, new PrintWriter(Console.err, true))
-
   /** Returns the number of errors issued totally as a string.
    *
    *  @param severity ...
@@ -43,7 +43,6 @@ class ConsoleReporter(val settings: Settings, reader: BufferedReader, writer: Pr
     countElementsAsString((severity).count, label(severity))
 
   /** Prints the message. */
-  //def printMessage(msg: String) { writer.println(msg) }  // platform-dependent!
   def printMessage(msg: String) { writer.print(msg + "\n"); writer.flush() }
 
   /** Prints the message with the given position indication. */
diff --git a/src/compiler/scala/tools/nsc/reporters/Reporter.scala b/src/compiler/scala/tools/nsc/reporters/Reporter.scala
index e253a8f5f0..063181b061 100644
--- a/src/compiler/scala/tools/nsc/reporters/Reporter.scala
+++ b/src/compiler/scala/tools/nsc/reporters/Reporter.scala
@@ -7,48 +7,22 @@ package scala.tools.nsc
 package reporters
 
 import scala.tools.nsc.util._
+import scala.tools.util.StringOps._
 
 /**
  * This interface provides methods to issue information, warning and
  * error messages.
  */
 abstract class Reporter {
+  protected def info0(pos: Position, msg: String, severity: Severity, force: Boolean): Unit
+
   object severity extends Enumeration
   class Severity(val id: Int) extends severity.Value {
     var count: Int = 0
   }
-  val INFO = new Severity(0)
+  val INFO    = new Severity(0)
   val WARNING = new Severity(1)
-  val ERROR = new Severity(2)
-
-  def reset() {
-    INFO.count = 0
-    ERROR.count   = 0
-    WARNING.count = 0
-    cancelled = false
-  }
-
-  var cancelled: Boolean = false
-  def hasErrors: Boolean = ERROR.count > 0 || cancelled
-  def hasWarnings: Boolean = WARNING.count > 0
-
-  /** Flush all output */
-  def flush() { }
-
-  protected def info0(pos: Position, msg: String, severity: Severity, force: Boolean): Unit
-
-  private var source: SourceFile = _
-  def setSource(source: SourceFile) { this.source = source }
-  def getSource: SourceFile = source
-  def withSource[A](src: SourceFile)(op: => A) = {
-    val oldSource = source
-    try {
-      source = src
-      op
-    } finally {
-      source = oldSource
-    }
-  }
+  val ERROR   = new Severity(2)
 
   /** Whether very long lines can be truncated.  This exists so important
    *  debugging information (like printing the classpath) is not rendered
@@ -63,64 +37,33 @@ abstract class Reporter {
     finally _truncationOK = saved
   }
 
+  private var incompleteHandler: (Position, String) => Unit = null
+  def incompleteHandled = incompleteHandler != null
+  def withIncompleteHandler[T](handler: (Position, String) => Unit)(thunk: => T) = {
+    val saved = incompleteHandler
+    incompleteHandler = handler
+    try thunk
+    finally incompleteHandler = saved
+  }
+
+  var cancelled         = false
+  def hasErrors         = ERROR.count > 0 || cancelled
+  def hasWarnings       = WARNING.count > 0
+
   def    info(pos: Position, msg: String, force: Boolean) { info0(pos, msg,    INFO, force) }
   def warning(pos: Position, msg: String                ) { info0(pos, msg, WARNING, false) }
   def   error(pos: Position, msg: String                ) { info0(pos, msg,   ERROR, false) }
-
-  def comment(pos: Position, msg: String) {}
-
-  /** An error that could possibly be fixed if the unit were longer.
-   *  This is used only when the interpreter tries
-   *  to distinguish fatal errors from those that are due to
-   *  needing more lines of input from the user.
-   *
-   * Should be re-factored into a subclass.
-   */
-  var incompleteInputError: (Position, String) => Unit = error
-  var incompleteHandled: Boolean = false
-
-  def withIncompleteHandler[T](handler: (Position, String) => Unit)(thunk: => T) = {
-    val savedHandler = incompleteInputError
-    val savedHandled = incompleteHandled
-    try {
-      incompleteInputError = handler
-      incompleteHandled = true
-      thunk
-    } finally {
-      incompleteInputError = savedHandler
-      incompleteHandled = savedHandled
-    }
+  def incompleteInputError(pos: Position, msg: String   ) {
+    if (incompleteHandled) incompleteHandler(pos, msg)
+    else error(pos, msg)
   }
 
-  // @M: moved here from ConsoleReporter and made public -- also useful in e.g. Typers
-  /** Returns a string meaning "n elements".
-   *
-   *  @param n        ...
-   *  @param elements ...
-   *  @return         ...
-   */
-  def countElementsAsString(n: Int, elements: String): String =
-    n match {
-      case 0 => "no "    + elements + "s"
-      case 1 => "one "   + elements
-      case 2 => "two "   + elements + "s"
-      case 3 => "three " + elements + "s"
-      case 4 => "four "  + elements + "s"
-      case _ => "" + n + " " + elements + "s"
-    }
-
-  /** Turns a count into a friendly English description if n<=4.
-   *
-   *  @param n        ...
-   *  @return         ...
-   */
-  def countAsString(n: Int): String =
-    n match {
-      case 0 => "none"
-      case 1 => "one"
-      case 2 => "two"
-      case 3 => "three"
-      case 4 => "four"
-      case _ => "" + n
-    }
+  def comment(pos: Position, msg: String) { }
+  def flush() { }
+  def reset() {
+    INFO.count        = 0
+    ERROR.count       = 0
+    WARNING.count     = 0
+    cancelled         = false
+  }
 }
diff --git a/src/compiler/scala/tools/nsc/reporters/StoreReporter.scala b/src/compiler/scala/tools/nsc/reporters/StoreReporter.scala
index 9f0e55c422..48601c325a 100644
--- a/src/compiler/scala/tools/nsc/reporters/StoreReporter.scala
+++ b/src/compiler/scala/tools/nsc/reporters/StoreReporter.scala
@@ -6,10 +6,8 @@
 package scala.tools.nsc
 package reporters
 
-import java.io.{BufferedReader, InputStreamReader, IOException, PrintWriter}
-
-import scala.collection.mutable.HashSet
-import scala.tools.nsc.util.{Position, SourceFile}
+import scala.collection.mutable
+import scala.tools.nsc.util.Position
 
 /**
  * This class implements a Reporter that displays messages on a text
@@ -19,7 +17,7 @@ class StoreReporter extends Reporter {
   class Info(val pos: Position, val msg: String, val severity: Severity) {
     override def toString() = "pos: " + pos + " " + msg + " " + severity
   }
-  val infos = new HashSet[Info]
+  val infos = new mutable.HashSet[Info]
   protected def info0(pos: Position, msg: String, severity: Severity, force: Boolean) {
     if (!force) {
       infos += new Info(pos, msg, severity)
@@ -28,7 +26,7 @@ class StoreReporter extends Reporter {
   }
 
   override def reset() {
-    super.reset
-    infos.clear
+    super.reset()
+    infos.clear()
   }
 }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
index 6c27bcace6..88cecbd402 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
@@ -9,6 +9,7 @@ package typechecker
 import scala.collection.{ mutable, immutable }
 import scala.collection.mutable.ListBuffer
 import scala.util.control.ControlThrowable
+import scala.tools.util.StringOps.{ countAsString, countElementsAsString }
 import symtab.Flags._
 
 /** This trait ...
@@ -1055,8 +1056,8 @@ trait Infer {
       errors foreach {case (targ, tparam, arityMismatches, varianceMismatches, stricterBounds) => errorMessages +=
         (targ+"'s type parameters do not match "+tparam+"'s expected parameters: "+
         (for ((a, p) <- arityMismatches)
-          yield a+qualify(a,p)+ " has "+reporter.countElementsAsString(a.typeParams.length, "type parameter")+", but "+
-            p+qualify(p,a)+" has "+reporter.countAsString(p.typeParams.length)).toList.mkString(", ") +
+          yield a+qualify(a,p)+ " has "+countElementsAsString(a.typeParams.length, "type parameter")+", but "+
+            p+qualify(p,a)+" has "+countAsString(p.typeParams.length)).toList.mkString(", ") +
         (for ((a, p) <- varianceMismatches)
           yield a+qualify(a,p)+ " is "+varStr(a)+", but "+
             p+qualify(p,a)+" is declared "+varStr(p)).toList.mkString(", ") +
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 59cb6c4081..c43fa377a4 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -16,9 +16,9 @@ import scala.collection.{ mutable, immutable }
 import scala.tools.nsc.util.BatchSourceFile
 import mutable.ListBuffer
 import symtab.Flags._
-
 import util.Statistics
 import util.Statistics._
+import scala.tools.util.StringOps.{ countAsString, countElementsAsString }
 
 // Suggestion check whether we can do without priming scopes with symbols of outer scopes,
 // like the IDE does.
@@ -825,8 +825,8 @@ trait Typers extends Modes {
               // Note that we treat Any and Nothing as kind-polymorphic.
               // We can't perform this check when typing type arguments to an overloaded method before the overload is resolved
               // (or in the case of an error type) -- this is indicated by pt == WildcardType (see case TypeApply in typed1).
-              errorTree(tree, tree.tpe+" takes "+reporter.countElementsAsString(tree.tpe.typeParams.length, "type parameter")+
-                              ", expected: "+reporter.countAsString(pt.typeParams.length))
+              errorTree(tree, tree.tpe+" takes "+countElementsAsString(tree.tpe.typeParams.length, "type parameter")+
+                              ", expected: "+countAsString(pt.typeParams.length))
               tree setType tree.tpe
           } else tree match { // (6)
             case TypeTree() => tree
diff --git a/src/compiler/scala/tools/util/StringOps.scala b/src/compiler/scala/tools/util/StringOps.scala
index 63cfc06702..65ff582011 100644
--- a/src/compiler/scala/tools/util/StringOps.scala
+++ b/src/compiler/scala/tools/util/StringOps.scala
@@ -16,7 +16,7 @@ package util
  *  @author Martin Odersky
  *  @version 1.0
  */
-object StringOps {
+trait StringOps {
   def onull(s: String)                    = if (s == null) "" else s
   def oempty(xs: String*)                 = xs filterNot (x => x == null || x == "")
   def ojoin(xs: Seq[String], sep: String) = oempty(xs: _*) mkString sep
@@ -53,4 +53,37 @@ object StringOps {
   def splitAt(str: String, idx: Int, doDropIndex: Boolean = false): Option[(String, String)] =
     if (idx == -1) None
     else Some(str take idx, str drop (if (doDropIndex) idx + 1 else idx))
+
+  /** Returns a string meaning "n elements".
+   *
+   *  @param n        ...
+   *  @param elements ...
+   *  @return         ...
+   */
+  def countElementsAsString(n: Int, elements: String): String =
+    n match {
+      case 0 => "no "    + elements + "s"
+      case 1 => "one "   + elements
+      case 2 => "two "   + elements + "s"
+      case 3 => "three " + elements + "s"
+      case 4 => "four "  + elements + "s"
+      case _ => "" + n + " " + elements + "s"
+    }
+
+  /** Turns a count into a friendly English description if n<=4.
+   *
+   *  @param n        ...
+   *  @return         ...
+   */
+  def countAsString(n: Int): String =
+    n match {
+      case 0 => "none"
+      case 1 => "one"
+      case 2 => "two"
+      case 3 => "three"
+      case 4 => "four"
+      case _ => "" + n
+    }
 }
+
+object StringOps extends StringOps { }