s/reportBuffer/reporter

5 files changed, 65 insertions, 66 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
index 06375d404b..1d4e2c8546 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
@@ -128,7 +128,7 @@ trait Contexts { self: Analyzer =>
         case Import(qual, _) => qual setType singleType(qual.symbol.owner.thisType, qual.symbol)
         case _               =>
       }
-      context.reportBuffer.clearAll()
+      context.reporter.clearAll()
     }
   }
 
@@ -324,14 +324,13 @@ trait Contexts { self: Analyzer =>
     // Error reporting policies and buffer.
     //
 
-    // TODO: start out with a regular reporter?
-    private var _reportBuffer: ContextReporter = new ThrowingReporter
+    private var _reporter: ContextReporter = new ThrowingReporter
 
     // the reporter for this context
-    def reportBuffer = _reportBuffer
+    def reporter = _reporter
 
     // if set, errors will not be reporter/thrown
-    def bufferErrors    = reportBuffer.isBuffering
+    def bufferErrors    = reporter.isBuffering
     def reportErrors    = !bufferErrors
 
     // whether to *report* (which is separate from buffering/throwing) ambiguity errors
@@ -349,9 +348,9 @@ trait Contexts { self: Analyzer =>
       def apply(): Unit =
         if (implicitsEnabled) {
           val savedContextMode = contextMode
-          val savedReporter = _reportBuffer
+          val savedReporter = _reporter
           var fallback = false
-          _reportBuffer = (new BufferingReporter).sharingBuffersWith(reportBuffer)
+          _reporter = (new BufferingReporter).sharingBuffersWith(reporter)
           setAmbiguousErrors(false)
           // We cache the current buffer because it is impossible to
           // distinguish errors that occurred before entering tryTwice
@@ -359,27 +358,27 @@ trait Contexts { self: Analyzer =>
           // first attempt fails we try with implicits on *and* clean
           // buffer but that would also flush any pre-tryTwice valid
           // errors, hence some manual buffer tweaking is necessary.
-          val errorsToRestore = reportBuffer.errors
-          reportBuffer.clearAllErrors()
+          val errorsToRestore = reporter.errors
+          reporter.clearAllErrors()
           try {
             withImplicitsDisabled(tryOnce(false))
-            if (reportBuffer.hasErrors) {
+            if (reporter.hasErrors) {
               fallback = true
               contextMode = savedContextMode
-              _reportBuffer = savedReporter
-              reportBuffer.clearAllErrors()
+              _reporter = savedReporter
+              reporter.clearAllErrors()
               tryOnce(true)
             }
           } catch {
             case ex: CyclicReference  => throw ex
             case ex: TypeError        => // recoverable cyclic references
               contextMode = savedContextMode
-              _reportBuffer = savedReporter
+              _reporter = savedReporter
               if (!fallback) tryOnce(true) else ()
           } finally {
             contextMode = savedContextMode
-            _reportBuffer = savedReporter
-            reportBuffer ++= errorsToRestore
+            _reporter = savedReporter
+            reporter ++= errorsToRestore
           }
         }
         else tryOnce(true)
@@ -425,14 +424,14 @@ trait Contexts { self: Analyzer =>
 
     /** @return true if the `expr` evaluates to true within a silent Context that incurs no errors */
     @inline final def inSilentMode(expr: => Boolean): Boolean = {
-      val savedReporter = _reportBuffer
+      val savedReporter = _reporter
       withMode() { // TODO: rework -- withMode with no arguments to restore the mode mutated by `setBufferErrors` (no longer mutated!)
-        _reportBuffer = (new BufferingReporter).sharingBuffersWith(reportBuffer)
+        _reporter = (new BufferingReporter).sharingBuffersWith(reporter)
         setAmbiguousErrors(false)
-        try expr && !reportBuffer.hasErrors
+        try expr && !reporter.hasErrors
         finally {
-          _reportBuffer = savedReporter
-          _reportBuffer.clearAll() // TODO: ???
+          _reporter = savedReporter
+          _reporter.clearAll() // TODO: ???
         }
       }
     }
@@ -481,7 +480,7 @@ trait Contexts { self: Analyzer =>
       c.diagUsedDefaults   = diagUsedDefaults
       c.openImplicits      = openImplicits
       c.contextMode        = contextMode // note: ConstructorSuffix, a bit within `mode`, is conditionally overwritten below.
-      c._reportBuffer      = _reportBuffer
+      c._reporter          = reporter
 
       // Fields that may take on a different value in the child
       c.prefix             = prefixInChild
@@ -498,7 +497,7 @@ trait Contexts { self: Analyzer =>
 
     /** Use reporter (possibly buffered) for errors/warnings and enable implicit conversion **/
     def initRootContext(throwing: Boolean = false, checking: Boolean = false): Unit = {
-      _reportBuffer =
+      _reporter =
         if (checking) new CheckingReporter
         else if (throwing) new ThrowingReporter
         else new ContextReporter // TODO: this is likely redundant
@@ -523,13 +522,13 @@ trait Contexts { self: Analyzer =>
       val c = make(newtree)
       c.setAmbiguousErrors(reportAmbiguousErrors)
       // A fresh buffer so as not to leak errors/warnings into `this`.
-      c._reportBuffer = new BufferingReporter
+      c._reporter = new BufferingReporter
       c
     }
 
     def makeNonSilent(newtree: Tree): Context = {
       val c = make(newtree)
-      c._reportBuffer = (new ContextReporter).sharingBuffersWith(reportBuffer)
+      c._reporter = (new ContextReporter).sharingBuffersWith(reporter)
       c.setAmbiguousErrors(true)
       c
     }
@@ -555,7 +554,7 @@ trait Contexts { self: Analyzer =>
       val baseContext = enclClass.outer.nextEnclosing(!_.tree.isInstanceOf[Template])
       val argContext = baseContext.makeNewScope(tree, owner)
       argContext.contextMode = contextMode
-      argContext._reportBuffer = _reportBuffer // caught by neg/t3649 TODO: make sure _reportBuffer is propagated wherever contextMode is
+      argContext._reporter = _reporter // caught by neg/t3649 TODO: make sure _reporter is propagated wherever contextMode is
       argContext.inSelfSuperCall = true
       def enterElems(c: Context) {
         def enterLocalElems(e: ScopeEntry) {
@@ -580,14 +579,14 @@ trait Contexts { self: Analyzer =>
     //
 
     /** Issue/buffer/throw the given type error according to the current mode for error reporting. */
-    private[typechecker] def issue(err: AbsTypeError)                        = reportBuffer.issue(err)(this)
+    private[typechecker] def issue(err: AbsTypeError)                        = reporter.issue(err)(this)
     /** Issue/buffer/throw the given implicit ambiguity error according to the current mode for error reporting. */
-    private[typechecker] def issueAmbiguousError(err: AbsAmbiguousTypeError) = reportBuffer.issueAmbiguousError(err)(this)
+    private[typechecker] def issueAmbiguousError(err: AbsAmbiguousTypeError) = reporter.issueAmbiguousError(err)(this)
     /** Issue/throw the given error message according to the current mode for error reporting. */
-    def error(pos: Position, msg: String)                                    = reportBuffer.error(pos, msg)
+    def error(pos: Position, msg: String)                                    = reporter.error(pos, msg)
     /** Issue/throw the given error message according to the current mode for error reporting. */
-    def warning(pos: Position, msg: String)                                  = reportBuffer.warning(pos, msg)
-    def echo(pos: Position, msg: String)                                     = reportBuffer.echo(pos, msg)
+    def warning(pos: Position, msg: String)                                  = reporter.warning(pos, msg)
+    def echo(pos: Position, msg: String)                                     = reporter.echo(pos, msg)
 
 
     def deprecationWarning(pos: Position, sym: Symbol, msg: String): Unit =
diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index 0a5521aff4..e03877dbf9 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -71,12 +71,12 @@ trait Implicits {
       typingStack.printTyping(tree, "typing implicit: %s %s".format(tree, context.undetparamsString))
     val implicitSearchContext = context.makeImplicit(reportAmbiguous)
     val result = new ImplicitSearch(tree, pt, isView, implicitSearchContext, pos).bestImplicit
-    if (result.isFailure && saveAmbiguousDivergent && implicitSearchContext.reportBuffer.hasErrors) {
-      context.reportBuffer ++= (implicitSearchContext.reportBuffer.errors.collect {
+    if (result.isFailure && saveAmbiguousDivergent && implicitSearchContext.reporter.hasErrors) {
+      context.reporter ++= (implicitSearchContext.reporter.errors.collect {
         case dte: DivergentImplicitTypeError => dte
         case ate: AmbiguousImplicitTypeError => ate
       })
-      debuglog("update buffer: " + implicitSearchContext.reportBuffer.errors)
+      debuglog("update buffer: " + implicitSearchContext.reporter.errors)
     }
     // SI-7944 undetermined type parameters that result from inference within typedImplicit land in
     //         `implicitSearchContext.undetparams`, *not* in `context.undetparams`
@@ -99,7 +99,7 @@ trait Implicits {
     def wrapper(inference: => SearchResult) = wrapper1(inference)
     val result = wrapper(inferImplicit(tree, pt, reportAmbiguous = true, isView = isView, context = context, saveAmbiguousDivergent = !silent, pos = pos))
     if (result.isFailure && !silent) {
-      val err = context.reportBuffer.firstError
+      val err = context.reporter.firstError
       val errPos = err.map(_.errPos).getOrElse(pos)
       val errMsg = err.map(_.errMsg).getOrElse("implicit search has failed. to find out the reason, turn on -Xlog-implicits")
       onError(errPos, errMsg)
@@ -635,7 +635,7 @@ trait Implicits {
             }
           case _ => fallback
         }
-        context.reportBuffer.firstError match { // using match rather than foreach to avoid non local return.
+        context.reporter.firstError match { // using match rather than foreach to avoid non local return.
           case Some(err) =>
             log("implicit adapt failed: " + err.errMsg)
             return fail(err.errMsg)
@@ -658,8 +658,8 @@ trait Implicits {
           }
         }
 
-        if (context.reportBuffer.hasErrors)
-          fail("hasMatchingSymbol reported error: " + context.reportBuffer.firstError.get.errMsg)
+        if (context.reporter.hasErrors)
+          fail("hasMatchingSymbol reported error: " + context.reporter.firstError.get.errMsg)
         else if (itree3.isErroneous)
           fail("error typechecking implicit candidate")
         else if (isLocalToCallsite && !hasMatchingSymbol(itree2))
@@ -677,7 +677,7 @@ trait Implicits {
 
             // #2421: check that we correctly instantiated type parameters outside of the implicit tree:
             checkBounds(itree3, NoPrefix, NoSymbol, undetParams, targs, "inferred ")
-            context.reportBuffer.firstError match {
+            context.reporter.firstError match {
               case Some(err) =>
                 return fail("type parameters weren't correctly instantiated outside of the implicit tree: " + err.errMsg)
               case None      =>
@@ -716,7 +716,7 @@ trait Implicits {
               case t                              => t
             }
 
-            context.reportBuffer.firstError match {
+            context.reporter.firstError match {
               case Some(err) =>
                 fail("typing TypeApply reported errors for the implicit tree: " + err.errMsg)
               case None      =>
@@ -861,7 +861,7 @@ trait Implicits {
               // We don't want errors that occur while checking the implicit info
               // to influence the check of further infos, but we should retain divergent implicit errors
               // (except for the one we already squirreled away)
-              context.reportBuffer.retainDivergentErrorsExcept(divergentError.getOrElse(null))
+              context.reporter.retainDivergentErrorsExcept(divergentError.getOrElse(null))
             }
             search
           }
@@ -907,7 +907,7 @@ trait Implicits {
           // the first `DivergentImplicitTypeError` that is being propagated
           // from a nested implicit search; this one will be
           // re-issued if this level of the search fails.
-          DivergentImplicitRecovery(typedFirstPending, firstPending, context.reportBuffer.errors) match {
+          DivergentImplicitRecovery(typedFirstPending, firstPending, context.reporter.errors) match {
             case sr if sr.isDivergent => Nil
             case sr if sr.isFailure   => rankImplicits(otherPending, acc)
             case newBest              =>
@@ -1144,7 +1144,7 @@ trait Implicits {
 
         try {
           val tree1 = typedPos(pos.focus)(arg)
-          context.reportBuffer.firstError match {
+          context.reporter.firstError match {
             case Some(err) => processMacroExpansionError(err.errPos, err.errMsg)
             case None      => new SearchResult(tree1, EmptyTreeTypeSubstituter, Nil)
           }
@@ -1357,8 +1357,8 @@ trait Implicits {
         if (Statistics.canEnable) Statistics.incCounter(inscopeImplicitHits)
       }
       if (result.isFailure) {
-        val previousErrs = context.reportBuffer.errors
-        context.reportBuffer.clearAllErrors()
+        val previousErrs = context.reporter.errors
+        context.reporter.clearAllErrors()
         val failstart = if (Statistics.canEnable) Statistics.startTimer(oftypeFailNanos) else null
         val succstart = if (Statistics.canEnable) Statistics.startTimer(oftypeSucceedNanos) else null
 
@@ -1370,7 +1370,7 @@ trait Implicits {
           result = searchImplicit(implicitsOfExpectedType, isLocalToCallsite = false)
 
         if (result.isFailure) {
-          context.reportBuffer ++= previousErrs
+          context.reporter ++= previousErrs
           if (Statistics.canEnable) Statistics.stopTimer(oftypeFailNanos, failstart)
         } else {
           if (Statistics.canEnable) Statistics.stopTimer(oftypeSucceedNanos, succstart)
@@ -1427,7 +1427,7 @@ trait Implicits {
         // thus, start each type var off with a fresh for every typedImplicit
         resetTVars()
         // any previous errors should not affect us now
-        context.reportBuffer.clearAllErrors()
+        context.reporter.clearAllErrors()
         val res = typedImplicit(ii, ptChecked = false, isLocalToCallsite)
         if (res.tree ne EmptyTree) List((res, tvars map (_.constr)))
         else Nil
diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
index 69ac9ea61e..535aaffbbf 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
@@ -779,7 +779,7 @@ trait Infer extends Checkable {
       def applicableExpectingPt(pt: Type): Boolean = {
         val silent = context.makeSilent(reportAmbiguousErrors = false)
         val result = newTyper(silent).infer.isApplicable(undetparams, ftpe, argtpes0, pt)
-        if (silent.reportBuffer.hasErrors && !pt.isWildcard)
+        if (silent.reporter.hasErrors && !pt.isWildcard)
           applicableExpectingPt(WildcardType) // second try
         else
           result
diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
index 66152a6ac2..d6870afb10 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
@@ -622,7 +622,7 @@ trait Macros extends MacroRuntimes with Traces with Helpers {
           // `macroExpandApply` is called from `adapt`, where implicit conversions are disabled
           // therefore we need to re-enable the conversions back temporarily
           val result = typer.context.withImplicitsEnabled(typer.typed(tree, mode, pt))
-          if (result.isErrorTyped && macroDebugVerbose) println(s"$label has failed: ${typer.context.reportBuffer.errors}")
+          if (result.isErrorTyped && macroDebugVerbose) println(s"$label has failed: ${typer.context.reporter.errors}")
           result
         }
       }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 65dc5148ad..c557af88f2 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -155,7 +155,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
           } else {
             mkArg = gen.mkNamedArg // don't pass the default argument (if any) here, but start emitting named arguments for the following args
             if (!param.hasDefault && !paramFailed) {
-              context.reportBuffer.reportFirstDivergentError(fun, param, paramTp)(context)
+              context.reporter.reportFirstDivergentError(fun, param, paramTp)(context)
               paramFailed = true
             }
             /* else {
@@ -466,20 +466,20 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
     @inline
     final def typerWithLocalContext[T](c: Context)(f: Typer => T): T = {
       val res = f(newTyper(c))
-      val errors = c.reportBuffer.errors
+      val errors = c.reporter.errors
       if (errors.nonEmpty) {
-        c.reportBuffer.clearAllErrors()
-        context.reportBuffer ++= errors
+        c.reporter.clearAllErrors()
+        context.reporter ++= errors
       }
       res
     }
 
     @inline
     final def withSavedContext[T](c: Context)(f: => T) = {
-      val savedErrors = c.reportBuffer.errors
-      c.reportBuffer.clearAllErrors()
+      val savedErrors = c.reporter.errors
+      c.reporter.clearAllErrors()
       val res = f
-      c.reportBuffer ++= savedErrors
+      c.reporter ++= savedErrors
       res
     }
 
@@ -687,23 +687,23 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
           context.undetparams = context1.undetparams
           context.savedTypeBounds = context1.savedTypeBounds
           context.namedApplyBlockInfo = context1.namedApplyBlockInfo
-          if (context1.reportBuffer.hasErrors) {
+          if (context1.reporter.hasErrors) {
             stopStats()
-            SilentTypeError(context1.reportBuffer.errors: _*)
+            SilentTypeError(context1.reporter.errors: _*)
           } else {
             // If we have a successful result, emit any warnings it created.
-            context1.reportBuffer.warnings foreach {
+            context1.reporter.warnings foreach {
               case (pos, msg) => reporter.warning(pos, msg)
             }
-            context1.reportBuffer.clearAllWarnings()
+            context1.reporter.clearAllWarnings()
             SilentResultValue(result)
           }
         } else {
           assert(context.bufferErrors || isPastTyper, "silent mode is not available past typer")
           withSavedContext(context){
             val res = op(this)
-            val errorsToReport = context.reportBuffer.errors
-            context.reportBuffer.clearAllErrors()
+            val errorsToReport = context.reporter.errors
+            context.reporter.clearAllErrors()
             if (errorsToReport.isEmpty) SilentResultValue(res) else SilentTypeError(errorsToReport.head)
           }
         }
@@ -810,14 +810,14 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
         }
 
         // avoid throwing spurious DivergentImplicit errors
-        if (context.reportBuffer.hasErrors)
+        if (context.reporter.hasErrors)
           setError(tree)
         else
           withCondConstrTyper(treeInfo.isSelfOrSuperConstrCall(tree))(typer1 =>
             if (original != EmptyTree && pt != WildcardType) (
               typer1 silent { tpr =>
                 val withImplicitArgs = tpr.applyImplicitArgs(tree)
-                if (tpr.context.reportBuffer.hasErrors) tree // silent will wrap it in SilentTypeError anyway
+                if (tpr.context.reporter.hasErrors) tree // silent will wrap it in SilentTypeError anyway
                 else tpr.typed(withImplicitArgs, mode, pt)
               }
               orElse { _ =>
@@ -1051,7 +1051,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
                 val silentContext = context.makeImplicit(context.ambiguousErrors)
                 val res = newTyper(silentContext).typed(
                   new ApplyImplicitView(coercion, List(tree)) setPos tree.pos, mode, pt)
-                silentContext.reportBuffer.firstError match {
+                silentContext.reporter.firstError match {
                   case Some(err) => context.issue(err)
                   case None      => return res
                 }
@@ -3223,7 +3223,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
                   (arg1, arg1.tpe.deconst)
               }.unzip
             }
-            if (context.reportBuffer.hasErrors)
+            if (context.reporter.hasErrors)
               setError(tree)
             else {
               inferMethodAlternative(fun, undetparams, argTpes, pt)
@@ -4324,7 +4324,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
         c.retyping = true
         try {
           val res = newTyper(c).typedArgs(args, mode)
-          if (c.reportBuffer.hasErrors) None else Some(res)
+          if (c.reporter.hasErrors) None else Some(res)
         } catch {
           case ex: CyclicReference =>
             throw ex