More words for misused using

Author: som-snytt

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

@@ -3731,6 +3731,8 @@ object Parsers {
 
       def addParamMod(mod: () => Mod) = impliedMods = addMod(impliedMods, atSpan(in.skipToken()) { mod() })
 
+      def paramModAdvice = "It is a keyword only at the beginning of a parameter clause."
+
       def paramMods() =
         if in.token == IMPLICIT then
           report.errorOrMigrationWarning(
@@ -3748,6 +3750,8 @@ object Parsers {
           if initialMods.is(Given) then
             syntaxError(em"`using` is already implied here, should not be given explicitly", in.offset)
           addParamMod(() => Mod.Given())
+          if in.isColon then
+            syntaxErrorOrIncomplete(ExpectedTokenButFoundSoftKeyword(IDENTIFIER, COLONop, nme.using, paramModAdvice))
 
       def param(): ValDef = {
         val start = in.offset
@@ -3774,8 +3778,20 @@ object Parsers {
           mods |= Param
         }
         atSpan(start, nameStart) {
-          val name = ident()
-          acceptColon()
+          val name = ident() match
+            case nme.using if !in.isColon =>
+              val msg = ExpectedTokenButFoundSoftKeyword(expected = COLONop, found = in.token, nme.using, paramModAdvice)
+              val span = Span(in.offset, in.offset + (if in.name != null then in.name.show.length else 0))
+              val pickOne =
+                if in.token == IDENTIFIER then
+                  while in.isSoftModifierInParamModifierPosition do ident() // skip to intended name, discard mods
+                  ident()
+                else nme.using
+              syntaxErrorOrIncomplete(msg, span)
+              pickOne
+            case name =>
+              acceptColon()
+              name
           if (in.token == ARROW && paramOwner.isClass && !mods.is(Local))
             syntaxError(VarValParametersMayNotBeCallByName(name, mods.is(Mutable)))
               // needed?, it's checked later anyway
@@ -3811,7 +3827,7 @@ object Parsers {
             syntaxError(em"`using` expected")
           Nil
         else
-          val clause =
+          val clause = {
             if paramOwner == ParamOwner.ExtensionPrefix
                 && !isIdent(nme.using) && !isIdent(nme.erased)
             then
@@ -3841,7 +3857,8 @@ object Parsers {
                 else contextTypes(paramOwner, numLeadParams, impliedMods)
               params match
                 case Nil => Nil
-                case (h :: t) => h.withAddedFlags(firstParamMod.flags) :: t
+                case h :: t => h.withAddedFlags(firstParamMod.flags) :: t
+          }
           checkVarArgsRules(clause)
           clause
       }

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

@@ -302,7 +302,7 @@ extends NotFoundMsg(MissingIdentID) {
         |imported from elsewhere.
         |
         |Possible reasons why no matching declaration was found:
-        | - The declaration or the use is mis-spelt.
+        | - The declaration or the use is misspelled.
         | - An import is missing.
         | - The declaration exists but refers to a type in a context where a term is expected, or vice-versa."""
   }
@@ -1272,6 +1272,17 @@ extends SyntaxMsg(ExpectedTokenButFoundID) {
       ""
 }
 
+class ExpectedTokenButFoundSoftKeyword(expected: Token, found: Token, soft: Name, advice: String = "")(using Context)
+extends SyntaxMsg(ExpectedTokenButFoundID):
+  def addendum = if !advice.isEmpty then s"\n$advice" else advice
+  def msg(using Context) =
+    val expectedText = if Tokens.isIdentifier(expected) then "an identifier" else Tokens.showToken(expected)
+    val what = if Tokens.isIdentifier(found) || expected == Tokens.COLONop then "an identifier" else "the soft keyword"
+    s"""$expectedText expected, but ${Tokens.showToken(found)} found
+       |The soft keyword `$soft` was taken as $what in this context.$addendum""".stripMargin
+  def explain(using Context) = s"The soft keyword `$soft` has special meaning only in certain contexts."
+end ExpectedTokenButFoundSoftKeyword
+
 class MixedLeftAndRightAssociativeOps(op1: Name, op2: Name, op2LeftAssoc: Boolean)(using Context)
 extends SyntaxMsg(MixedLeftAndRightAssociativeOpsID) {
   def msg(using Context) =

compiler/test/dotty/tools/vulpix/ParallelTesting.scala

@@ -948,7 +948,12 @@ trait ParallelTesting extends RunnerOrchestration:
 
       Option {
         if actualErrors == 0 then s"\nNo errors found when compiling neg test $testSource"
-        else if expectedErrors == 0 then s"\nNo errors expected/defined in $testSource -- use // error or // nopos-error"
+        else if expectedErrors == 0 then
+          s"""|No expected errors marked in $testSource -- use // error or // nopos-error
+              |actual error count: $actualErrors
+              |${unexpected.mkString("Unexpected errors:\n", "\n", "")}
+              |$showErrors
+              |""".stripMargin.trim.linesIterator.mkString("\n", "\n", "")
         else if expectedErrors != actualErrors then
           s"""|Wrong number of errors encountered when compiling $testSource
               |expected: $expectedErrors, actual: $actualErrors

tests/neg/22550.check

@@ -32,7 +32,7 @@
   | imported from elsewhere.
   |
   | Possible reasons why no matching declaration was found:
-  |  - The declaration or the use is mis-spelt.
+  |  - The declaration or the use is misspelled.
   |  - An import is missing.
   |  - The declaration exists but refers to a type in a context where a term is expected, or vice-versa.
    ---------------------------------------------------------------------------------------------------------------------

tests/neg/22550b.check

@@ -32,7 +32,7 @@
    | imported from elsewhere.
    |
    | Possible reasons why no matching declaration was found:
-   |  - The declaration or the use is mis-spelt.
+   |  - The declaration or the use is misspelled.
    |  - An import is missing.
    |  - The declaration exists but refers to a type in a context where a term is expected, or vice-versa.
     --------------------------------------------------------------------------------------------------------------------