Report the correct errors in the IDE

In some situations (like when interpolating type variables) the logic
changes depending on whether we have unreported errors or not.
Before this commit, we assumed that any error in a StoreReporter was
unreported, but this is wrong: the IDE, the REPL and other tools use
a StoreReporter as their root reporter.

This commit fixes this by making sure all the code that looks for
unreported errors does so by calling `hasUnreportedErrors` and
making that method return false when there is no outer reporter.

Author: smarter

compiler/src/dotty/tools/dotc/reporting/Reporter.scala

@@ -238,8 +238,10 @@ abstract class Reporter extends interfaces.ReporterResult {
   def isHidden(m: MessageContainer)(implicit ctx: Context): Boolean =
     ctx.mode.is(Mode.Printing)
 
-  /** Does this reporter contain not yet reported errors or warnings? */
-  def hasPendingErrors: Boolean = false
+  /** Does this reporter contains errors that have yet to be reported by its outer reporter ?
+   *  Note: this is always false when there is no outer reporter.
+   */
+  def hasUnreportedErrors: Boolean = false
 
   /** If this reporter buffers messages, remove and return all buffered messages. */
   def removeBufferedMessages(implicit ctx: Context): List[MessageContainer] = Nil

compiler/src/dotty/tools/dotc/reporting/StoreReporter.scala

@@ -28,8 +28,8 @@ class StoreReporter(outer: Reporter) extends Reporter {
     infos += m
   }
 
-  override def hasPendingErrors: Boolean =
-    infos != null && infos.exists(_.isInstanceOf[Error])
+  override def hasUnreportedErrors: Boolean =
+    outer != null && infos != null && infos.exists(_.isInstanceOf[Error])
 
   override def removeBufferedMessages(implicit ctx: Context): List[MessageContainer] =
     if (infos != null) try infos.toList finally infos = null

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

@@ -432,10 +432,7 @@ trait Inferencing { this: Typer =>
       //     found   : Int(1)
       //     required: String
       //     val y: List[List[String]] = List(List(1))
-      val hasUnreportedErrors = state.reporter match {
-        case r: StoreReporter if r.hasErrors => true
-        case _ => false
-      }
+      val hasUnreportedErrors = state.reporter.hasUnreportedErrors
       def constraint = state.constraint
       for (tvar <- qualifying)
         if (!tvar.isInstantiated && state.constraint.contains(tvar)) {

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

@@ -264,7 +264,7 @@ object ProtoTypes {
           targ = arg.withType(WildcardType)
         else {
           targ = typerFn(arg)
-          if (!ctx.reporter.hasPendingErrors) {
+          if (!ctx.reporter.hasUnreportedErrors) {
             // FIXME: This can swallow warnings by updating the typerstate from a nested
             // context that gets discarded later. But we do have to update the
             // typerstate if there are no errors. If we also omitted the next two lines

language-server/test/dotty/tools/languageserver/DiagnosticsTest.scala

@@ -15,4 +15,14 @@ class DiagnosticsTest {
         (m1 to m2, """found:    String("foo")
                      |required: Int""".stripMargin, Error, Some(TypeMismatchID))
       )
+
+  @Test def diagnosticMissingLambdaBody: Unit =
+    code"""object Test {
+          |  Nil.map(x => x).filter(x$m1 =>$m2)
+          |$m3}""".withSource
+      .diagnostics(m1,
+        (m2 to m3, "illegal start of simple expression", Error, Some(IllegalStartSimpleExprID)),
+        (m1 to m1, """found:    Null
+                     |required: Boolean""".stripMargin, Error, Some(TypeMismatchID))
+      )
 }