improve parser recovery when top level function is missing parameters

pkg/analyzer/test/generated/parser_test.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 engine.parser_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
@@ skipping 1177 matching lines @@
     ParserTestCase.parseCompilationUnit(
         "void f(final x()) {}", [ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR]);
   }
 
   void test_functionTypedParameter_var() {
     ParserTestCase.parseCompilationUnit(
         "void f(var x()) {}", [ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR]);
   }
 
   void test_getterInFunction_block_noReturnType() {
-    ParserTestCase.parseStatement(
+    FunctionDeclarationStatement statement = ParserTestCase.parseStatement(
         "get x { return _x; }", [ParserErrorCode.GETTER_IN_FUNCTION]);
+    expect(statement.functionDeclaration.functionExpression.parameters, isNull);
   }
 
   void test_getterInFunction_block_returnType() {
     ParserTestCase.parseStatement(
         "int get x { return _x; }", [ParserErrorCode.GETTER_IN_FUNCTION]);
   }
 
   void test_getterInFunction_expression_noReturnType() {
     ParserTestCase.parseStatement(
         "get x => _x;", [ParserErrorCode.GETTER_IN_FUNCTION]);
@@ skipping 268 matching lines @@
     ParserTestCase.parseCompilationUnit(
         "int f { return x;}", [ParserErrorCode.MISSING_FUNCTION_PARAMETERS]);
   }
 
   void test_missingFunctionParameters_topLevel_nonVoid_expression() {
     ParserTestCase.parseCompilationUnit(
         "int f => x;", [ParserErrorCode.MISSING_FUNCTION_PARAMETERS]);
   }
 
   void test_missingFunctionParameters_topLevel_void_block() {
-    ParserTestCase.parseCompilationUnit(
+    CompilationUnit unit = ParserTestCase.parseCompilationUnit(
         "void f { return x;}", [ParserErrorCode.MISSING_FUNCTION_PARAMETERS]);
+    FunctionDeclaration funct = unit.declarations[0];
+    expect(funct.functionExpression.parameters, hasLength(0));
   }
 
   void test_missingFunctionParameters_topLevel_void_expression() {
-    ParserTestCase.parseCompilationUnit(
+    CompilationUnit unit = ParserTestCase.parseCompilationUnit(
         "void f => x;", [ParserErrorCode.MISSING_FUNCTION_PARAMETERS]);
+    FunctionDeclaration funct = unit.declarations[0];
+    expect(funct.functionExpression.parameters, hasLength(0));
   }
 
   void test_missingIdentifier_afterOperator() {
     parse4("parseMultiplicativeExpression", "1 *",
         [ParserErrorCode.MISSING_IDENTIFIER]);
   }
 
   void test_missingIdentifier_beforeClosingCurly() {
     parse3("parseClassMember", <Object>["C"], "int}", [
       ParserErrorCode.MISSING_IDENTIFIER,
@@ skipping 42 matching lines @@
     parse3("parseClassMember", <Object>["C"], "int +() {}",
         [ParserErrorCode.MISSING_KEYWORD_OPERATOR]);
   }
 
   void test_missingKeywordOperator_parseClassMember_afterVoid() {
     parse3("parseClassMember", <Object>["C"], "void +() {}",
         [ParserErrorCode.MISSING_KEYWORD_OPERATOR]);
   }
 
   void test_missingMethodParameters_void_block() {
-    parse3("parseClassMember", <Object>["C"], "void m {} }",
+    MethodDeclaration method = parse3("parseClassMember",
+        <Object>["C"], "void m {} }",
         [ParserErrorCode.MISSING_METHOD_PARAMETERS]);
+    expect(method.parameters, hasLength(0));
   }
 
   void test_missingMethodParameters_void_expression() {
     parse3("parseClassMember", <Object>["C"], "void m => null; }",
         [ParserErrorCode.MISSING_METHOD_PARAMETERS]);
   }
 
   void test_missingNameInLibraryDirective() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(
         "library;", [ParserErrorCode.MISSING_NAME_IN_LIBRARY_DIRECTIVE]);
@@ skipping 281 matching lines @@
 
   void test_switchHasMultipleDefaultCases_repeated() {
     parse4("parseSwitchStatement",
         "switch (a) {default: return 0; default: return 1; default: return 2;}",
         [
       ParserErrorCode.SWITCH_HAS_MULTIPLE_DEFAULT_CASES,
       ParserErrorCode.SWITCH_HAS_MULTIPLE_DEFAULT_CASES
     ]);
   }
 
+  void test_topLevel_getter() {
+    FunctionDeclaration funct = parse3("parseCompilationUnitMember",
+        <Object>[emptyCommentAndMetadata()],
+        "get x => 7;");
+    expect(funct.functionExpression.parameters, isNull);
+  }
+
   void test_topLevelOperator_withoutType() {
     parse3("parseCompilationUnitMember", <Object>[emptyCommentAndMetadata()],
         "operator +(bool x, bool y) => x | y;",
         [ParserErrorCode.TOP_LEVEL_OPERATOR]);
   }
 
   void test_topLevelOperator_withType() {
     parse3("parseCompilationUnitMember", <Object>[emptyCommentAndMetadata()],
         "bool operator +(bool x, bool y) => x | y;",
         [ParserErrorCode.TOP_LEVEL_OPERATOR]);
@@ skipping 3557 matching lines @@
     MethodDeclaration method =
         parse("parseClassMember", <Object>["C"], "void get g {}");
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNotNull);
     expect(method.returnType, isNotNull);
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
     expect(method.body, isNotNull);
+    expect(method.parameters, isNull);
   }
 
   void test_parseClassMember_method_external() {
     MethodDeclaration method =
         parse("parseClassMember", <Object>["C"], "external m();");
     expect(method.body, isNotNull);
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNotNull);
     expect(method.modifierKeyword, isNull);
     expect(method.name, isNotNull);
@@ skipping 4573 matching lines @@
         new Scanner(null, new CharSequenceReader(source), listener);
     Token tokenStream = scanner.tokenize();
     //
     // Parse the source.
     //
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(
         parser, methodName, <Object>[tokenStream], tokenStream) as Token;
   }
 }