Improve error recovery around 'scoped' modifier parsing

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -6996,6 +6996,12 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_ScopedMismatchInParameterOfPartial" xml:space="preserve">
     <value>The 'scoped' modifier of parameter '{0}' doesn't match partial definition.</value>
   </data>
+  <data name="ERR_ScopedAfterInOutRefReadonly" xml:space="preserve">
+    <value>The 'scoped' modifier cannot come after an 'in', 'out', 'ref' or 'readonly' modifier.</value>
+  </data>
+  <data name="ERR_InvalidModifierAfterScoped" xml:space="preserve">
+    <value>The '{0}' modifier cannot immediately follow the 'scoped' modifier.</value>
+  </data>
   <data name="ERR_FixedFieldMustNotBeRef" xml:space="preserve">
     <value>A fixed field must not be a ref field.</value>
   </data>

src/Compilers/CSharp/Portable/Errors/ErrorCode.cs

@@ -2448,6 +2448,9 @@ internal enum ErrorCode
         ERR_ExtensionParameterInStaticContext = 9347,
         ERR_CompilationUnitUnexpected = 9348,
 
+        ERR_ScopedAfterInOutRefReadonly = 9349,
+        ERR_InvalidModifierAfterScoped = 9350,
+
         // Note: you will need to do the following after adding errors:
         //  1) Update ErrorFacts.IsBuildOnlyDiagnostic (src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs)
         //  2) Add message to CSharpResources.resx

src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs

@@ -2555,6 +2555,8 @@ or ErrorCode.ERR_EqualityOperatorInPatternNotSupported
                 or ErrorCode.ERR_InequalityOperatorInPatternNotSupported
                 or ErrorCode.ERR_DesignatorBeforePropertyPattern
                 or ErrorCode.ERR_CompilationUnitUnexpected
+                or ErrorCode.ERR_ScopedAfterInOutRefReadonly
+                or ErrorCode.ERR_InvalidModifierAfterScoped
                     => false,
             };
 #pragma warning restore CS8524 // The switch expression does not handle some values of its input type (it is not exhaustive) involving an unnamed enum value.

src/Compilers/CSharp/Portable/Errors/MessageID.cs

@@ -487,7 +487,7 @@ internal static LanguageVersion RequiredVersion(this MessageID feature)
                 // C# preview features.
                 //return LanguageVersion.Preview;
 
-                // C# 13.0 features.
+                // C# 14.0 features.
                 case MessageID.IDS_FeatureFieldKeyword:
                 case MessageID.IDS_FeatureFirstClassSpan:
                 case MessageID.IDS_FeatureUnboundGenericTypesInNameof:

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

@@ -4834,7 +4834,9 @@ private bool IsPossibleParameter()
                     return this.IsTrueIdentifier();
 
                 default:
-                    return IsParameterModifierExcludingScoped(this.CurrentToken) || IsPossibleScopedKeyword(isFunctionPointerParameter: false) || IsPredefinedType(this.CurrentToken.Kind);
+                    return IsParameterModifierExcludingScoped(this.CurrentToken) ||
+                           IsDefiniteScopedModifier(isFunctionPointerParameter: false, isLambdaParameter: false) ||
+                           IsPredefinedType(this.CurrentToken.Kind);
             }
         }
 
@@ -4961,32 +4963,50 @@ private static bool IsParameterModifierExcludingScoped(SyntaxToken token)
 
         private void ParseParameterModifiers(SyntaxListBuilder modifiers, bool isFunctionPointerParameter, bool isLambdaParameter)
         {
-            bool tryScoped = true;
+            Debug.Assert(!(isFunctionPointerParameter && isLambdaParameter), "Can't be parsing parameters for both a function pointer and a lambda at the same time");
 
-            while (IsParameterModifierExcludingScoped(this.CurrentToken))
+            var seenScoped = false;
+            while (true)
             {
-                if (this.CurrentToken.Kind is SyntaxKind.RefKeyword or SyntaxKind.OutKeyword or SyntaxKind.InKeyword or SyntaxKind.ReadOnlyKeyword)
+                // Normal keyword-modifier (in/out/ref/readonly/params/this).  Always safe to consume.
+                if (IsParameterModifierExcludingScoped(this.CurrentToken))
                 {
-                    tryScoped = false;
+                    modifiers.Add(this.EatToken());
+                    continue;
                 }
 
-                modifiers.Add(this.EatToken());
-            }
-
-            if (tryScoped)
-            {
-                SyntaxToken scopedKeyword = ParsePossibleScopedKeyword(isFunctionPointerParameter, isLambdaParameter);
-
-                if (scopedKeyword != null)
+                // 'scoped' modifier.  May be ambiguous with a type/identifier.  And has changed parsing rules between
+                // C#13/14 inside a lambda parameter list.
+                if (this.IsDefiniteScopedModifier(isFunctionPointerParameter, isLambdaParameter))
                 {
-                    modifiers.Add(scopedKeyword);
-
-                    // Look if ref/out/in/readonly are next
-                    while (this.CurrentToken.Kind is SyntaxKind.RefKeyword or SyntaxKind.OutKeyword or SyntaxKind.InKeyword or SyntaxKind.ReadOnlyKeyword)
+                    // First scoped-modifier is always considered the modifier.
+                    if (!seenScoped)
                     {
-                        modifiers.Add(this.EatToken());
+                        seenScoped = true;
+                        modifiers.Add(this.EatContextualToken(SyntaxKind.ScopedKeyword));
+                        continue;
+                    }
+                    else
+                    {
+                        // If we've already seen `scoped` then we may have a situation like `scoped scoped`. This could
+                        // be duplicated modifier, or it could be that the second `scoped` is actually the identifier of
+                        // a parameter.
+                        //
+                        // Places where it is an identifier are:
+                        //
+                        //      `(scoped scoped) =>`
+                        //      `(scoped scoped, ...) =>`
+                        //      `(scoped scoped = ...) =>`
+                        if (this.PeekToken(1).Kind is not (SyntaxKind.CloseParenToken or SyntaxKind.CommaToken or SyntaxKind.EqualsToken))
+                        {
+                            modifiers.Add(this.EatContextualToken(SyntaxKind.ScopedKeyword));
+                            continue;
+                        }
                     }
                 }
+
+                // Not a modifier.  We're done.
+                return;
             }
         }
 
@@ -8464,7 +8484,7 @@ private bool IsPossibleLocalDeclarationStatement(bool isGlobalScriptLevel)
                 return true;
             }
 
-            if (IsPossibleScopedKeyword(isFunctionPointerParameter: false))
+            if (IsDefiniteScopedModifier(isFunctionPointerParameter: false, isLambdaParameter: false))
             {
                 return true;
             }
@@ -8482,12 +8502,6 @@ private bool IsPossibleLocalDeclarationStatement(bool isGlobalScriptLevel)
             return IsPossibleFirstTypedIdentifierInLocalDeclarationStatement(isGlobalScriptLevel);
         }
 
-        private bool IsPossibleScopedKeyword(bool isFunctionPointerParameter)
-        {
-            using var _ = this.GetDisposableResetPoint(resetOnDispose: true);
-            return ParsePossibleScopedKeyword(isFunctionPointerParameter, isLambdaParameter: false) != null;
-        }
-
         private bool IsPossibleFirstTypedIdentifierInLocalDeclarationStatement(bool isGlobalScriptLevel)
         {
             bool? typedIdentifier = IsPossibleTypedIdentifierStart(this.CurrentToken, this.PeekToken(1), allowThisKeyword: false);
@@ -8623,7 +8637,7 @@ private bool IsPossibleTopLevelUsingLocalDeclarationStatement()
             // Skip 'using' keyword
             EatToken();
 
-            if (IsPossibleScopedKeyword(isFunctionPointerParameter: false))
+            if (IsDefiniteScopedModifier(isFunctionPointerParameter: false, isLambdaParameter: false))
             {
                 return true;
             }
@@ -10518,41 +10532,34 @@ private StatementSyntax ParseLocalDeclarationStatement(SyntaxList<AttributeListS
             }
         }
 
-        private SyntaxToken ParsePossibleScopedKeyword(
+        private bool IsDefiniteScopedModifier(
             bool isFunctionPointerParameter,
             bool isLambdaParameter)
         {
             if (this.CurrentToken.ContextualKind != SyntaxKind.ScopedKeyword)
-                return null;
+                return false;
 
-            // In C# 14 we decided that within a lambda 'scoped' would *always* be a keyword.
+            // In C# 14 we decided that within a lambda 'scoped' would *always* be a modifier, not a type.
+            // so `scoped scoped` is `modifier-scoped identifier-scoped` not `type-scoped identifier-scoped`.
+            // Note: this only applies the modifier/type portion.  We still allow the identifier of a lambda
+            // to be named 'scoped'.
             if (isLambdaParameter && IsFeatureEnabled(MessageID.IDS_FeatureSimpleLambdaParameterModifiers))
-                return this.EatContextualToken(SyntaxKind.ScopedKeyword);
+                return true;
 
-            using var beforeScopedResetPoint = this.GetDisposableResetPoint(resetOnDispose: false);
+            using var beforeScopedResetPoint = this.GetDisposableResetPoint(resetOnDispose: true);
 
             var scopedKeyword = this.EatContextualToken(SyntaxKind.ScopedKeyword);
 
-            // trivial case.  scoped ref/out/in  is definitely the scoped keyword.
-            if (this.CurrentToken.Kind is (SyntaxKind.RefKeyword or SyntaxKind.OutKeyword or SyntaxKind.InKeyword))
-                return scopedKeyword;
+            // trivial case.  scoped ref/out/in/this  is definitely the scoped keyword. Note: the only actual legal
+            // cases are `scoped ref`, `scoped out`, and `scoped in`.  But we detect and allow `scoped this`, `scoped
+            // params` and `scoped readonly` as well.  These will be reported as errors later in binding.
+            if (IsParameterModifierExcludingScoped(this.CurrentToken))
+                return true;
 
             // More complex cases.  We have to check for `scoped Type ...` now.
-            using var afterScopedResetPoint = this.GetDisposableResetPoint(resetOnDispose: false);
-
-            if (ScanType() is ScanTypeFlags.NotType ||
-                !isValidScopedTypeCase())
-            {
-                // We didn't see a type, or it wasn't a legal usage of a type.  This is not a scoped-keyword.  Rollback to
-                // before the keyword so the caller has to handle it.
-                beforeScopedResetPoint.Reset();
-                return null;
-            }
-
-            // We had a Type syntax in a supported production.  Roll back to just after the scoped-keyword and
-            // return it successfully.
-            afterScopedResetPoint.Reset();
-            return scopedKeyword;
+            //
+            // Note that `scoped scoped` can be valid here as a type called scoped and a variable called scoped.
+            return ScanType() is not ScanTypeFlags.NotType && isValidScopedTypeCase();
 
             bool isValidScopedTypeCase()
             {
@@ -10574,6 +10581,15 @@ bool isValidScopedTypeCase()
             }
         }
 
+        private SyntaxToken ParsePossibleScopedKeyword(
+            bool isFunctionPointerParameter,
+            bool isLambdaParameter)
+        {
+            return IsDefiniteScopedModifier(isFunctionPointerParameter, isLambdaParameter)
+                ? this.EatContextualToken(SyntaxKind.ScopedKeyword)
+                : null;
+        }
+
         private VariableDesignationSyntax ParseDesignation(bool forPattern)
         {
             // the two forms of designation are

src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs

@@ -608,8 +608,9 @@ internal static void CheckParameterModifiers(
             bool seenReadonly = false;
 
             SyntaxToken? previousModifier = null;
-            foreach (var modifier in parameter.Modifiers)
+            for (int i = 0, n = parameter.Modifiers.Count; i < n; i++)
             {
+                var modifier = parameter.Modifiers[i];
                 switch (modifier.Kind())
                 {
                     case SyntaxKind.ThisKeyword:
@@ -775,10 +776,27 @@ internal static void CheckParameterModifiers(
 
                     case SyntaxKind.ScopedKeyword when parameterContext is not ParameterContext.FunctionPointer:
                         ModifierUtils.CheckScopedModifierAvailability(parameter, modifier, diagnostics);
-                        Debug.Assert(!seenIn);
-                        Debug.Assert(!seenOut);
-                        Debug.Assert(!seenRef);
-                        Debug.Assert(!seenScoped);
+
+                        if (seenScoped)
+                        {
+                            addERR_DupParamMod(diagnostics, modifier);
+                        }
+                        else if (seenIn || seenOut || seenRef || seenReadonly)
+                        {
+                            // Disallow parsing out 'scoped' once in/out/ref/readonly had been seen.
+                            diagnostics.Add(ErrorCode.ERR_ScopedAfterInOutRefReadonly, modifier.GetLocation());
+                        }
+                        else if (i < n - 1)
+                        {
+                            // Only allow `scoped` followed by `ref/out/in` to actually be considered a valid modifier.
+                            // Anything else is an error.
+                            //
+                            // Note we don't add an error in the case of 'scoped scoped' as that is already handled by
+                            // seenScoped above.
+                            var nextModifier = parameter.Modifiers[i + 1];
+                            if (nextModifier.Kind() is not (SyntaxKind.RefKeyword or SyntaxKind.OutKeyword or SyntaxKind.InKeyword or SyntaxKind.ScopedKeyword))
+                                diagnostics.Add(ErrorCode.ERR_InvalidModifierAfterScoped, nextModifier.GetLocation(), nextModifier.Text);
+                        }
 
                         seenScoped = true;
                         break;
@@ -1165,7 +1183,6 @@ internal static RefKind GetModifiers(SyntaxTokenList modifiers, bool ignoreParam
                         thisKeyword = modifier;
                         break;
                     case SyntaxKind.ScopedKeyword:
-                        Debug.Assert(refKind == RefKind.None);
                         isScoped = true;
                         break;
                     case SyntaxKind.ReadOnlyKeyword: