Merge pull request #5484 from dotty-staging/fix-error-pos-2

 Report the correct errors in the IDE and add test infrastructure for diagnostics

Author: Duhemm

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 contain 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/reporting/diagnostic/messages.scala

@@ -291,11 +291,10 @@ object messages {
     val kind: String = "Type Mismatch"
     val msg: String = {
       val (where, printCtx) = Formatting.disambiguateTypes(found, expected)
+      val whereSuffix = if (where.isEmpty) where else s"\n\n$where"
       val (fnd, exp) = Formatting.typeDiff(found, expected)(printCtx)
       s"""|found:    $fnd
-          |required: $exp
-          |
-          |$where""".stripMargin + whyNoMatch + implicitFailure
+          |required: $exp""".stripMargin + whereSuffix + whyNoMatch + implicitFailure
     }
 
     val explanation: String = ""

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

compiler/src/dotty/tools/dotc/util/ParsedComment.scala

@@ -117,7 +117,6 @@ object ParsedComment {
     "@throws"  -> TagFormatter("Throws", toDescriptionList),
     "@see"     -> TagFormatter("See Also", toMarkdownList),
     "@example" -> TagFormatter("Examples", toCodeFences("scala")),
-    "@usecase" -> TagFormatter("Usecases", toCodeFences("scala")),
     "@note"    -> TagFormatter("Note", toMarkdownList),
     "@author"  -> TagFormatter("Authors", toMarkdownList),
     "@since"   -> TagFormatter("Since", toMarkdownList),

compiler/test-resources/repl/errmsgs

@@ -5,36 +5,30 @@ scala> val x: List[String] = List(1)
   |                            ^
   |                            found:    Int(1)
   |                            required: String
-  |
 scala> val y: List[List[String]] = List(List(1))
 1 | val y: List[List[String]] = List(List(1))
   |                                       ^
   |                                       found:    Int(1)
   |                                       required: String
-  |
 scala> val z: (List[String], List[Int]) = (List(1), List("a"))
 1 | val z: (List[String], List[Int]) = (List(1), List("a"))
   |                                          ^
   |                                          found:    Int(1)
   |                                          required: String
-  |
 1 | val z: (List[String], List[Int]) = (List(1), List("a"))
   |                                                   ^^^
   |                                                   found:    String("a")
   |                                                   required: Int
-  |
 scala> val a: Inv[String] = new Inv(new Inv(1))
 1 | val a: Inv[String] = new Inv(new Inv(1))
   |                              ^^^^^^^^^^
   |                              found:    Inv[Int]
   |                              required: String
-  |
 scala> val b: Inv[String] = new Inv(1)
 1 | val b: Inv[String] = new Inv(1)
   |                              ^
   |                              found:    Int(1)
   |                              required: String
-  |
 scala> abstract class C { type T; val x: T; val s: Unit = { type T = String; var y: T = x; locally { def f() = { type T = Int; val z: T = y }; f() } }; }
 1 | abstract class C { type T; val x: T; val s: Unit = { type T = String; var y: T = x; locally { def f() = { type T = Int; val z: T = y }; f() } }; }
   |                                                                                  ^
@@ -59,7 +53,6 @@ scala> val x: List[Int] = "foo" :: List(1)
   |                    ^^^^^
   |                    found:    String("foo")
   |                    required: Int
-  |
 scala> { def f: Int = g; val x: Int = 1; def g: Int = 5; }
 1 | { def f: Int = g; val x: Int = 1; def g: Int = 5; }
   |                ^

compiler/test-resources/repl/importFromObj

@@ -9,7 +9,6 @@ scala> buf += xs
   |        ^^
   |        found:    List[Int](o.xs)
   |        required: Int
-  |
 scala> buf ++= xs
 val res0: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)
 scala> import util.foo

compiler/test-resources/type-printer/type-mismatch

@@ -7,4 +7,3 @@ scala> val x: Foo[String] = res0
   |                      ^^^^
   |                      found:    Foo[Int](res0)
   |                      required: Foo[String]
-  |

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

@@ -0,0 +1,41 @@
+package dotty.tools.languageserver
+
+import org.junit.Test
+
+import dotty.tools.dotc.reporting.diagnostic.ErrorMessageID._
+import dotty.tools.languageserver.util.Code._
+import org.eclipse.lsp4j.DiagnosticSeverity._
+
+class DiagnosticsTest {
+  @Test def diagnosticWrongType: Unit =
+    code"""object Test {
+          |  val x: Int = $m1"foo"$m2
+          |}""".withSource
+      .diagnostics(m1,
+        (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))
+      )
+
+  @Test def diagnosticPureExpression: Unit =
+    code"""object Test {
+          |  ${m1}1$m2
+          |}""".withSource
+     .diagnostics(m1,
+       (m1 to m2,
+        "a pure expression does nothing in statement position; you may be omitting necessary parentheses",
+        Warning, Some(PureExpressionInStatementPositionID)))
+
+  @Test def diagnosticWorksheetPureExpression: Unit =
+    ws"""${m1}1""".withSource
+     .diagnostics(m1 /* no "pure expression" warning because this is a worksheet */)
+}