Fix parse error location for missing syntax at end of line

When trailing syntax is missing (e.g., `type Money is Currency` instead of
`Currency(USD)`), fastparse reports the error at the next token's position
rather than where the expected token was missing. Added adjustFailureIndex()
that walks backward past whitespace and adjusts the location when it crosses
a newline boundary, so errors point to the end of the offending line.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: reid-spencer

language/shared/src/main/scala/com/ossuminc/riddl/language/parsing/ParsingErrors.scala

@@ -64,8 +64,31 @@ trait ParsingErrors {
       .mkString("(", " | ", ")")
   }
 
+  /** When a parse failure occurs, the failure index points to where
+    * fastparse found the unexpected token (the "next" token). For
+    * better UX, we want to point to where the expected token was
+    * missing — just after the last successfully consumed token.
+    * Only adjust if the next token is on a different line (crossing
+    * a newline), which is the case that confuses users the most.
+    */
+  private def adjustFailureIndex(index: Int, input: RiddlParserInput): Int =
+    val data = input.data
+    if index <= 0 || index > data.length then index
+    else
+      var i = index - 1
+      // Walk backward past whitespace
+      while i >= 0 && data(i).isWhitespace do i -= 1
+      // Only adjust if we crossed a newline
+      if i >= 0 && input.lineOf(i) < input.lineOf(index.min(data.length - 1)) then
+        i + 1 // Just after last non-whitespace char
+      else
+        index // Same line — keep original
+    end if
+  end adjustFailureIndex
+
   def makeParseFailureError(failure: Failure, input: RiddlParserInput): Unit = {
-    val location = input.location(failure.index)
+    val adjustedIndex = adjustFailureIndex(failure.index, input)
+    val location = input.location(adjustedIndex)
     val trace = failure.trace()
     val msg = trace.terminals.value.size match {
       case 0 => "Expected nothing"

language/shared/src/test/scala/com/ossuminc/riddl/language/parsing/CommonParserTest.scala

@@ -133,6 +133,33 @@ abstract class CommonParserTest(using PlatformContext) extends AbstractParsingTe
       }
     }
   }
+  "ParseErrorLocation" should {
+    "report error at end of offending line, not start of next line" in { (td: TestData) =>
+      // "type Money is Currency" is missing the type arguments e.g. Currency(USD)
+      // The error should point to line 2 (where "Currency" ends), not line 3
+      val input = RiddlParserInput(
+        "domain foo is {\n  type Money is Currency\n}\n",
+        td
+      )
+      parseTopLevelDomains(input) match
+        case Right(_) => fail("Expected parse failure but parsing succeeded")
+        case Left(messages) =>
+          val errors = messages.justErrors
+          errors must not be empty
+          // The error about the incomplete type should be on line 2
+          // (where "Currency" is), not line 3 (where "}" is)
+          val errorOnLine2 = errors.exists(_.loc.line == 2)
+          val errorOnLine3Only = errors.forall(_.loc.line == 3)
+          if errorOnLine3Only then
+            fail(
+              s"Error incorrectly reported on line 3 instead of line 2: " +
+                errors.map(m => s"${m.loc.line}:${m.loc.col} ${m.message}").mkString("; ")
+            )
+          end if
+          errorOnLine2 mustBe true
+    }
+  }
+
   "NoWhiteSpaceParsers" should {
     "handle a URL" in { (td: TestData) =>
       val input = RiddlParserInput("https://www.wordnik.com/words/phi", td)