Refinements

 1. Indicate error after last token only if it appears on line
    before current token
 2. Apply the same scheme to missing patterns

I tried to apply it to missing types as well, but there it is not so easy.
I got follow-up errors that I would not get with the existing scheme. So
in summary it's not clear that the change for types would be worth it.

Author: odersky

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

@@ -105,6 +105,13 @@ object Parsers {
     def sourcePos(off: Int = in.offset): SourcePosition =
       source atPos Position(off)
 
+    /** in.offset, except if this is at a new line, in which case `lastOffset` is preferred. */
+    def expectedOffset: Int = {
+      val current = sourcePos(in.offset)
+      val last = sourcePos(in.lastOffset)
+      if (current.line != last.line) in.lastOffset else in.offset
+    }
+
     /* ------------- ERROR HANDLING ------------------------------------------- */
     /** The offset where the last syntax error was reported, or if a skip to a
       *  safepoint occurred afterwards, the offset of the safe point.
@@ -116,7 +123,7 @@ object Parsers {
       */
     def syntaxError(msg: => Message, offset: Int = in.offset): Unit =
       if (offset > lastErrorOffset) {
-        val length = if (in.name != null) in.name.show.length else 0
+        val length = if (offset == in.offset && in.name != null) in.name.show.length else 0
         syntaxError(msg, Position(offset, offset + length))
         lastErrorOffset = in.offset
       }
@@ -1456,7 +1463,7 @@ object Parsers {
         case _ =>
           if (isLiteral) literal()
           else {
-            syntaxErrorOrIncomplete(IllegalStartSimpleExpr(tokenString(in.token)), in.lastOffset)
+            syntaxErrorOrIncomplete(IllegalStartSimpleExpr(tokenString(in.token)), expectedOffset)
             errorTermTree
           }
       }
@@ -1748,7 +1755,7 @@ object Parsers {
       case _ =>
         if (isLiteral) literal(inPattern = true)
         else {
-          syntaxErrorOrIncomplete(IllegalStartOfSimplePattern())
+          syntaxErrorOrIncomplete(IllegalStartOfSimplePattern(), expectedOffset)
           errorTermTree
         }
     }

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -922,7 +922,7 @@ object messages {
   case class IllegalStartOfSimplePattern()(implicit ctx: Context)
   extends Message(IllegalStartOfSimplePatternID) {
     val kind: String = "Syntax"
-    val msg: String = "Illegal start of simple pattern"
+    val msg: String = "pattern expected"
     val explanation: String = {
       val sipCode =
         """def f(x: Int, y: Int) = x match {

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

@@ -21,7 +21,7 @@ class DiagnosticsTest {
           |  Nil.map(x => x).filter(x$m1 =>$m2)
           |$m3}""".withSource
       .diagnostics(m1,
-        (m2 to m3, "Illegal start of simple expression", Error, Some(IllegalStartSimpleExprID)),
+        (m2 to m3, "expression expected", Error, Some(IllegalStartSimpleExprID)),
         (m1 to m1, """Found:    Null
                      |Required: Boolean""".stripMargin, Error, Some(TypeMismatchID))
       )

tests/neg/errpos.scala

@@ -1,4 +1,23 @@
 object Test {
   val x =     // error: expression expected
   val y = 2   // error: ';' expected
+
+  val z =     // error: expression expected
+
+  // ...
+  val a = 3   // error: ';' expected
+
+  val b = type // error: expression expected (on "type")
+
+  type T1 =  // error: type expected
+
+  type T2 = String  // error: ';' expected
+  type T3 = this    // error: Expected an additional member selection after the keyword this
+
+  type T4 =   ;     // error: type expected
+
+  1 match {
+    case            // error: pattern expected
+    case 2 => ""
+  }
 }