Reduce Context iface: encapsulate buffer manipulation.

4 files changed, 44 insertions, 37 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
index 028ac46058..99cd027df0 100644
--- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
@@ -132,6 +132,23 @@ trait ContextErrors {
   def MacroCantExpandIncompatibleMacrosError(internalMessage: String) =
     MacroIncompatibleEngineError("macro cannot be expanded, because it was compiled by an incompatible macro engine", internalMessage)
 
+  def NoImplicitFoundError(tree: Tree, param: Symbol)(implicit context: Context): Unit = {
+    def errMsg = {
+      val paramName = param.name
+      val paramTp = param.tpe
+      def evOrParam = (
+        if (paramName startsWith nme.EVIDENCE_PARAM_PREFIX)
+          "evidence parameter of type"
+        else
+          s"parameter $paramName:")
+      paramTp.typeSymbolDirect match {
+        case ImplicitNotFoundMsg(msg) => msg.format(paramName, paramTp)
+        case _ => s"could not find implicit value for $evOrParam $paramTp"
+      }
+    }
+    issueNormalTypeError(tree, errMsg)
+  }
+
   trait TyperContextErrors {
     self: Typer =>
 
@@ -150,24 +167,6 @@ trait ContextErrors {
         setError(tree)
       }
 
-      def NoImplicitFoundError(tree: Tree, param: Symbol) = {
-        def errMsg = {
-          val paramName = param.name
-          val paramTp   = param.tpe
-          def evOrParam = (
-            if (paramName startsWith nme.EVIDENCE_PARAM_PREFIX)
-              "evidence parameter of type"
-            else
-              s"parameter $paramName:"
-          )
-          paramTp.typeSymbolDirect match {
-            case ImplicitNotFoundMsg(msg) => msg.format(paramName, paramTp)
-            case _ => s"could not find implicit value for $evOrParam $paramTp"
-          }
-        }
-        issueNormalTypeError(tree, errMsg)
-      }
-
       def AdaptTypeError(tree: Tree, found: Type, req: Type) = {
         // SI-3971 unwrapping to the outermost Apply helps prevent confusion with the
         // error message point.
diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
index 1010ceafe3..56f945623b 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
@@ -1343,6 +1343,31 @@ trait Contexts { self: Analyzer =>
 
     def hasErrors     = errorBuffer.nonEmpty
     def firstError    = errorBuffer.headOption
+
+    // have to pass in context because multiple contexts may share the same ReportBuffer
+    def reportFirstDivergentError(fun: Tree, param: Symbol, paramTp: Type)(implicit context: Context): Unit =
+      errors.collectFirst {
+        case dte: DivergentImplicitTypeError => dte
+      } match {
+        case Some(divergent) =>
+          // DivergentImplicit error has higher priority than "no implicit found"
+          // no need to issue the problem again if we are still in silent mode
+          if (context.reportErrors) {
+            context.issue(divergent.withPt(paramTp))
+            errorBuffer.retain {
+              case dte: DivergentImplicitTypeError => false
+              case _ => true
+            }
+          }
+        case _ =>
+          NoImplicitFoundError(fun, param)(context)
+      }
+
+    def retainDivergentErrorsExcept(saved: DivergentImplicitTypeError) =
+      errorBuffer.retain {
+        case err: DivergentImplicitTypeError => err ne saved
+        case _ => false
+      }
   }
 
   class ImportInfo(val tree: Import, val depth: Int) {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index e4925b939e..ed773f0178 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -861,10 +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)
-              val saved = divergentError.getOrElse(null)
-              context.reportBuffer.retainErrors {
-                case err: DivergentImplicitTypeError => err ne saved
-              }
+              context.reportBuffer.retainDivergentErrorsExcept(divergentError.getOrElse(null))
             }
             search
           }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 44755c650c..65dc5148ad 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -155,21 +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.errors.collectFirst {
-                case dte: DivergentImplicitTypeError => dte
-              } match {
-                case Some(divergent) =>
-                  // DivergentImplicit error has higher priority than "no implicit found"
-                  // no need to issue the problem again if we are still in silent mode
-                  if (context.reportErrors) {
-                    context.issue(divergent.withPt(paramTp))
-                    context.reportBuffer.clearErrors {
-                      case dte: DivergentImplicitTypeError => true
-                    }
-                  }
-                case _ =>
-                  NoImplicitFoundError(fun, param)
-              }
+              context.reportBuffer.reportFirstDivergentError(fun, param, paramTp)(context)
               paramFailed = true
             }
             /* else {