Expand span errorTermTree to include skipped span.

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -377,7 +377,7 @@ object Parsers {
       false
     }
 
-    def errorTermTree: Literal = atSpan(in.offset) { Literal(Constant(null)) }
+    def errorTermTree(start: Offset): Literal = atSpan(start, in.offset, in.offset) { Literal(Constant(null)) }
 
     private var inFunReturnType = false
     private def fromWithinReturnType[T](body: => T): T = {
@@ -1931,7 +1931,7 @@ object Parsers {
               PolyFunction(tparams, body)
             else {
               syntaxError("Implementation restriction: polymorphic function literals must have a value parameter", arrowOffset)
-              errorTermTree
+              errorTermTree(arrowOffset)
             }
           }
         case _ =>
@@ -2298,8 +2298,9 @@ object Parsers {
             in.nextToken()
             simpleExpr(location)
           else
+            val start = in.lastOffset
             syntaxErrorOrIncomplete(IllegalStartSimpleExpr(tokenString(in.token)), expectedOffset)
-            errorTermTree
+            errorTermTree(start)
       }
       simpleExprRest(t, location, canApply)
     }
@@ -2738,8 +2739,9 @@ object Parsers {
       case _ =>
         if (isLiteral) literal(inPattern = true)
         else {
+          val start = in.lastOffset
           syntaxErrorOrIncomplete(IllegalStartOfSimplePattern(), expectedOffset)
-          errorTermTree
+          errorTermTree(start)
         }
     }
 
@@ -3314,8 +3316,9 @@ object Parsers {
           }
           val rhs2 =
             if rhs.isEmpty && !isAllIds then
+              val start = in.lastOffset
               syntaxError(ExpectedTokenButFound(EQUALS, in.token), Span(in.lastOffset))
-              errorTermTree
+              errorTermTree(start)
             else
               rhs
           PatDef(mods, lhs, tpt, rhs2)
@@ -3483,11 +3486,12 @@ object Parsers {
         case GIVEN =>
           givenDef(start, mods, atSpan(in.skipToken()) { Mod.Given() })
         case _ =>
+          val start = in.lastOffset
           syntaxErrorOrIncomplete(ExpectedStartOfTopLevelDefinition())
           mods.annotations match {
             case head :: Nil => head
             case Nil => EmptyTree
-            case all => Block(all, errorTermTree)
+            case all => Block(all, errorTermTree(start))
           }
       }
 

compiler/src/dotty/tools/dotc/parsing/xml/MarkupParsers.scala

@@ -131,7 +131,7 @@ object MarkupParsers {
             try handle.parseAttribute(Span(start, curOffset, mid), tmp)
             catch {
               case e: RuntimeException =>
-                errorAndResult("error parsing attribute value", parser.errorTermTree)
+                errorAndResult("error parsing attribute value", parser.errorTermTree(parser.in.offset))
             }
 
           case '{'  =>
@@ -334,7 +334,7 @@ object MarkupParsers {
       finally parser.in.resume(saved)
 
       if (output == null)
-        parser.errorTermTree
+        parser.errorTermTree(parser.in.offset)
       else
         output
     }

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

@@ -21,9 +21,7 @@ class DiagnosticsTest {
           |  Nil.map(x => x).filter(x$m1 =>$m2)$m3
           |}""".withSource
       .diagnostics(m1,
-        (m2 to m2, "expression expected but ')' found", Error, Some(IllegalStartSimpleExprID)),
-        (m1 to m1, """Found:    Null
-                     |Required: Boolean""".stripMargin, Error, Some(TypeMismatchID))
+        (m2 to m2, "expression expected but ')' found", Error, Some(IllegalStartSimpleExprID))
       )
 
   @Test def diagnosticPureExpression: Unit =

tests/neg/arg-eof.scala

@@ -1,3 +1,3 @@
 object Test:
   case class Widget(name: String, other: Int = 5)
-  Widget(name = "foo", // error // error
+  Widget(name = "foo", // error

tests/neg/errpos.scala

@@ -10,7 +10,7 @@ object Test {
   val b = type // error: expression expected (on "type")
 
   1 match {
-    case            // error: pattern expected // error: cannot compare with Null
+    case            // error: pattern expected
     case 2 => ""
   }
-}
+}

tests/neg/i12150.check

@@ -4,9 +4,3 @@
   |             expression expected but end found
   |
   | longer explanation available when compiling with `-explain`
--- [E129] Potential Issue Warning: tests/neg/i12150.scala:1:11 ---------------------------------------------------------
-1 |def f: Unit = // error
-  |           ^
-  |           A pure expression does nothing in statement position; you may be omitting necessary parentheses
-  |
-  | longer explanation available when compiling with `-explain`

tests/neg/i1846.scala

@@ -3,17 +3,17 @@ object Test {
     val x = 42
     val Y = "42"
 
-    x match { case { 42 }           => () } // error // error
-    x match { case { 42.toString }  => () } // error // error
-    x match { case { 42 }.toString  => () } // error // error
+    x match { case { 42 }           => () } // error
+    x match { case { 42.toString }  => () } // error
+    x match { case { 42 }.toString  => () } // error
     x match { case "42".toInt       => () } // error
-    x match { case { "42".toInt }   => () } // error // error
-    x match { case { "42" }.toInt   => () } // error // error
-    x match { case { "42".toInt }   => () } // error // error
+    x match { case { "42".toInt }   => () } // error
+    x match { case { "42" }.toInt   => () } // error
+    x match { case { "42".toInt }   => () } // error
     x match { case Y                => () } // error
-    x match { case { Y.toInt }      => () } // error // error
-    x match { case { Y }.toInt      => () } // error // error
-    x match { case { Y }.toString   => () } // error // error
-    x match { case { Y.toString }   => () } // error // error
+    x match { case { Y.toInt }      => () } // error
+    x match { case { Y }.toInt      => () } // error
+    x match { case { Y }.toString   => () } // error
+    x match { case { Y.toString }   => () } // error
   }
 }

tests/neg/i3812.scala

@@ -3,11 +3,11 @@ object Test {
     val x = 42
     val Y = "42"
 
-    x match { case { 42 }           => () } // error // error
-    x match { case { "42".toInt }   => () } // error // error
-    x match { case { "42" }.toInt   => () } // error // error
-    x match { case { "42".toInt }   => () } // error // error
-    x match { case { Y.toInt }      => () } // error // error
-    x match { case { Y }.toInt      => () } // error // error
+    x match { case { 42 }           => () } // error
+    x match { case { "42".toInt }   => () } // error
+    x match { case { "42" }.toInt   => () } // error
+    x match { case { "42".toInt }   => () } // error
+    x match { case { Y.toInt }      => () } // error
+    x match { case { Y }.toInt      => () } // error
   }
 }

tests/neg/i5004.scala

@@ -1,6 +1,6 @@
 object i0 {
 1 match {
 def this(): Int  // error
-  def this()
+  def this()  // error
+}
 }
-}

tests/neg/i7742.scala

@@ -1,3 +1,3 @@
 object A {
-    for // error // error
-}
+    for // error
+}

tests/neg/parser-stability-25.scala

@@ -11,5 +11,5 @@ class D extends (Int => 1) {
 }
 
 class Wrap(x: Int)
-class E extends (Wrap)( // error
+class E extends (Wrap)(
 // error

tests/neg/parser-stability-27.scala

@@ -1,2 +1,2 @@
-class F extends (Int => 1)( // error
+class F extends (Int => 1)(
 // error

tests/neg/parser-stability-5.scala

@@ -1,4 +1,4 @@
 trait x0 {
 x1 : {   // error
-var x2   // error
+var x2
 // error

tests/neg/t5702-neg-bad-and-wild.check

@@ -1,15 +1,19 @@
 -- [E032] Syntax Error: tests/neg/t5702-neg-bad-and-wild.scala:10:22 ---------------------------------------------------
-10 |      case List(1, _*,) => // error: pattern expected // error
+10 |      case List(1, _*,) => // error: pattern expected
    |                      ^
    |                      pattern expected
    |
    | longer explanation available when compiling with `-explain`
 -- [E032] Syntax Error: tests/neg/t5702-neg-bad-and-wild.scala:12:23 ---------------------------------------------------
-12 |      case List(1, _*3,) => // error: pattern expected // error // error
+12 |      case List(1, _*3,) => // error: pattern expected // error
    |                       ^
    |                       pattern expected
    |
    | longer explanation available when compiling with `-explain`
+-- [E040] Syntax Error: tests/neg/t5702-neg-bad-and-wild.scala:13:23 ---------------------------------------------------
+13 |      case List(1, _*3:) =>  // error // error
+   |                       ^
+   |                       an identifier expected, but ')' found
 -- [E032] Syntax Error: tests/neg/t5702-neg-bad-and-wild.scala:15:18 ---------------------------------------------------
 15 |      case List(x*, 1) => // error: pattern expected
    |                  ^
@@ -34,17 +38,15 @@
    |    x is already defined as value x
    |
    |    Note that overloaded methods must all be defined in the same group of toplevel definitions
--- Error: tests/neg/t5702-neg-bad-and-wild.scala:10:21 -----------------------------------------------------------------
-10 |      case List(1, _*,) => // error: pattern expected // error
-   |                     ^
-   |                     Values of types Null and Int cannot be compared with == or !=
 -- [E006] Not Found Error: tests/neg/t5702-neg-bad-and-wild.scala:12:20 ------------------------------------------------
-12 |      case List(1, _*3,) => // error: pattern expected // error // error
+12 |      case List(1, _*3,) => // error: pattern expected // error
+   |                    ^
+   |                    Not found: *
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E006] Not Found Error: tests/neg/t5702-neg-bad-and-wild.scala:13:20 ------------------------------------------------
+13 |      case List(1, _*3:) =>  // error // error
    |                    ^
    |                    Not found: *
    |
    | longer explanation available when compiling with `-explain`
--- Error: tests/neg/t5702-neg-bad-and-wild.scala:12:22 -----------------------------------------------------------------
-12 |      case List(1, _*3,) => // error: pattern expected // error // error
-   |                      ^
-   |                      Values of types Null and Int cannot be compared with == or !=

tests/neg/t5702-neg-bad-and-wild.scala

@@ -7,10 +7,10 @@ object Test {
     val is = List(1,2,3)
 
     is match {
-      case List(1, _*,) => // error: pattern expected // error
+      case List(1, _*,) => // error: pattern expected
 
-      case List(1, _*3,) => // error: pattern expected // error // error
-      //case List(1, _*3:) =>  // poor recovery by parens
+      case List(1, _*3,) => // error: pattern expected // error
+      case List(1, _*3:) =>  // error // error
       case List(1, x*) => // ok
       case List(x*, 1) => // error: pattern expected
       case (1, x*) => //ok

tests/neg/trailingCommas.scala

@@ -2,10 +2,10 @@ package foo
 
 // Multi-line only cases: make sure trailing commas are only supported when multi-line
 
-trait ArgumentExprs1 { validMethod(23, "bar", )(Ev0, Ev1) } // error // error
-trait ArgumentExprs2 { validMethod(23, "bar")(Ev0, Ev1, ) } // error // error
-trait ArgumentExprs3 { new ValidClass(23, "bar", )(Ev0, Ev1) } // error // error
-trait ArgumentExprs4 { new ValidClass(23, "bar")(Ev0, Ev1, ) } // error // error
+trait ArgumentExprs1 { validMethod(23, "bar", )(Ev0, Ev1) } // error
+trait ArgumentExprs2 { validMethod(23, "bar")(Ev0, Ev1, ) } // error
+trait ArgumentExprs3 { new ValidClass(23, "bar", )(Ev0, Ev1) } // error
+trait ArgumentExprs4 { new ValidClass(23, "bar")(Ev0, Ev1, ) } // error
 
 trait Params1 { def f(foo: Int, bar: String, )(implicit ev0: Ev0, ev1: Ev1, ) = 1 } // error // error
 
@@ -55,4 +55,4 @@ object `package` {
 
   case class Foo(foo: Any)
   case class Bar(foo: Any)
-}
+}