Fix recovery to prevent generating a parameter with no name and no type (issue 30020)

pkg/analyzer/lib/src/generated/parser.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.parser;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 162 matching lines @@
 
   static String _SHOW = Keyword.SHOW.lexeme;
 
   static String SYNC = Keyword.SYNC.lexeme;
 
   static String _YIELD = Keyword.YIELD.lexeme;
 
   static const int _MAX_TREE_DEPTH = 300;
 
   /**
+   * A flag indicating whether the analyzer [Parser] factory method
+   * will return a fasta based parser or an analyzer based parser.
+   */
+  static bool useFasta = const bool.fromEnvironment("useFastaParser");
+
+  /**
    * The source being parsed.
    */
   final Source _source;
 
   /**
    * The error listener that will be informed of any errors that are found
    * during the parse.
    */
   final AnalysisErrorListener _errorListener;
 
@@ skipping 70 matching lines @@
   @deprecated
   bool parseGenericMethods = false;
 
   /**
    * A flag indicating whether to parse generic method comments, of the form
    * `/*=T*/` and `/*<T>*/`.
    */
   bool parseGenericMethodComments = false;
 
   /**
-   * A flag indicating whether the analyzer [Parser] factory method
-   * will return a fasta based parser or an analyzer based parser.
-   */
-  static bool useFasta = const bool.fromEnvironment("useFastaParser");
-
-  /**
    * Initialize a newly created parser to parse tokens in the given [_source]
    * and to report any errors that are found to the given [_errorListener].
    */
   factory Parser(Source source, AnalysisErrorListener errorListener,
       {bool useFasta}) {
     if (useFasta ?? Parser.useFasta) {
       return new _Parser2(source, errorListener);
     } else {
       return new Parser.withoutFasta(source, errorListener);
     }
@@ skipping 2592 matching lines @@
       type = _parseOptionalTypeNameComment();
       if (type != null) {
         // Clear the keyword to prevent an error.
         keywordToken = null;
       }
     } else if (_isTypedIdentifier(_currentToken)) {
       type = parseReturnType(false);
     } else if (inFunctionType && _matchesIdentifier()) {
       type = parseTypeAnnotation(false);
     } else if (!optional) {
+      // If there is a valid type immediately following an unexpected token,
+      // then report and skip the unexpected token.
+      Token next = _peek();
+      Keyword nextKeyword = next.keyword;
+      if (nextKeyword == Keyword.FINAL ||
+          nextKeyword == Keyword.CONST ||
+          nextKeyword == Keyword.VAR ||
+          _isTypedIdentifier(next) ||
+          inFunctionType && _tokenMatchesIdentifier(next)) {
+        _reportErrorForCurrentToken(
+            ParserErrorCode.UNEXPECTED_TOKEN, [_currentToken.lexeme]);
+        _advance();
+        return parseFinalConstVarOrType(optional,
+            inFunctionType: inFunctionType);
+      }
       _reportErrorForCurrentToken(
           ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE);
     } else {
       // Support parameters such as `(/*=K*/ key, /*=V*/ value)`
       // This is not supported if the type is required.
       type = _parseOptionalTypeNameComment();
     }
     return new FinalConstVarOrType(keywordToken, type);
   }
 
@@ skipping 5725 matching lines @@
     }
   }
 }
 
 /**
  * Instances of this class are thrown when the parser detects that AST has
  * too many nested expressions to be parsed safely and avoid possibility of
  * [StackOverflowError] in the parser or during later analysis.
  */
 class _TooDeepTreeError {}