diff --git a/pkg/analyzer/test/generated/parser_test.dart b/pkg/analyzer/test/generated/parser_test.dart
index 56f90ba..7b529d3 100644
--- a/pkg/analyzer/test/generated/parser_test.dart
+++ b/pkg/analyzer/test/generated/parser_test.dart
@@ -4495,12 +4495,12 @@
     // being reported in code that cannot actually be reached), but that hasn't
     // been proven yet.
     createParser('(int a, int b ;',
-        expectedEndOffset: 0 /* ErrorToken at end of token stream */);
+        expectedEndOffset: 14 /* ErrorToken at end of token stream */);
     FormalParameterList list = parser.parseFormalParameterList();
     expectNotNullIfNoErrors(list);
     if (usingFastaParser) {
-      listener
-          .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 14, 1)]);
+      // Fasta scanner reports missing `)` error
+      listener.assertNoErrors();
     } else if (fe.Scanner.useFasta) {
       listener.errors
           .contains(expectedError(ParserErrorCode.EXPECTED_TOKEN, 14, 1));
diff --git a/pkg/analyzer/test/src/fasta/recovery/partial_code/method_declaration_test.dart b/pkg/analyzer/test/src/fasta/recovery/partial_code/method_declaration_test.dart
index a2c8624..aacff92 100644
--- a/pkg/analyzer/test/src/fasta/recovery/partial_code/method_declaration_test.dart
+++ b/pkg/analyzer/test/src/fasta/recovery/partial_code/method_declaration_test.dart
@@ -12,6 +12,15 @@
 
 class MethodTest extends PartialCodeTest {
   buildAll() {
+    const allExceptEof = const [
+      'field',
+      'fieldConst',
+      'fieldFinal',
+      'methodNonVoid',
+      'methodVoid',
+      'getter',
+      'setter'
+    ];
     buildTests(
       'method_declaration',
       [
@@ -21,44 +30,52 @@
         new TestDescriptor(
           'noType_leftParen',
           'm(',
-          [ParserErrorCode.EXPECTED_TOKEN],
-          'm();',
-          allFailing: true,
+          [
+            ScannerErrorCode.EXPECTED_TOKEN,
+            ParserErrorCode.MISSING_FUNCTION_BODY
+          ],
+          'm() {}',
+          failing: allExceptEof,
         ),
         new TestDescriptor(
           'noType_paramName',
           'm(B',
-          [ParserErrorCode.EXPECTED_TOKEN],
-          'm(B);',
-          allFailing: true,
+          [
+            ScannerErrorCode.EXPECTED_TOKEN,
+            ParserErrorCode.MISSING_FUNCTION_BODY
+          ],
+          'm(B) {}',
+          failing: ['methodNonVoid', 'getter', 'setter'],
         ),
         new TestDescriptor(
-          'noType_paramTypeAndName',
-          'm(B b',
-          [ParserErrorCode.EXPECTED_TOKEN],
-          'm(B b);',
-          allFailing: true,
-        ),
+            'noType_paramTypeAndName',
+            'm(B b',
+            [
+              ScannerErrorCode.EXPECTED_TOKEN,
+              ParserErrorCode.MISSING_FUNCTION_BODY
+            ],
+            'm(B b) {}'),
         new TestDescriptor(
           'noType_paramAndComma',
           'm(B b,',
-          [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
-          'm(B b, _s_);',
-          allFailing: true,
+          [
+            ScannerErrorCode.EXPECTED_TOKEN,
+            ParserErrorCode.MISSING_FUNCTION_BODY
+          ],
+          'm(B b) {}',
+          failing: allExceptEof,
         ),
         new TestDescriptor(
           'noType_noParams',
           'm()',
-          [ParserErrorCode.EXPECTED_TOKEN],
-          'm();',
-          allFailing: true,
+          [ParserErrorCode.MISSING_FUNCTION_BODY],
+          'm() {}',
         ),
         new TestDescriptor(
           'noType_params',
           'm(b, c)',
-          [ParserErrorCode.EXPECTED_TOKEN],
-          'm(b, c);',
-          allFailing: true,
+          [ParserErrorCode.MISSING_FUNCTION_BODY],
+          'm(b, c) {}',
         ),
         new TestDescriptor(
           'noType_emptyOptional',
@@ -84,44 +101,53 @@
         new TestDescriptor(
           'type_leftParen',
           'A m(',
-          [ParserErrorCode.EXPECTED_TOKEN],
-          'A m();',
-          allFailing: true,
+          [
+            ScannerErrorCode.EXPECTED_TOKEN,
+            ParserErrorCode.MISSING_FUNCTION_BODY
+          ],
+          'A m() {}',
+          failing: allExceptEof,
         ),
         new TestDescriptor(
           'type_paramName',
           'A m(B',
-          [ParserErrorCode.EXPECTED_TOKEN],
-          'A m(B);',
-          allFailing: true,
+          [
+            ScannerErrorCode.EXPECTED_TOKEN,
+            ParserErrorCode.MISSING_FUNCTION_BODY
+          ],
+          'A m(B) {}',
+          failing: ['methodNonVoid', 'getter', 'setter'],
         ),
         new TestDescriptor(
           'type_paramTypeAndName',
           'A m(B b',
-          [ParserErrorCode.EXPECTED_TOKEN],
-          'A m(B b);',
-          allFailing: true,
+          [
+            ScannerErrorCode.EXPECTED_TOKEN,
+            ParserErrorCode.MISSING_FUNCTION_BODY
+          ],
+          'A m(B b) {}',
         ),
         new TestDescriptor(
           'type_paramAndComma',
           'A m(B b,',
-          [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
-          'A m(B b, _s_);',
-          allFailing: true,
+          [
+            ScannerErrorCode.EXPECTED_TOKEN,
+            ParserErrorCode.MISSING_FUNCTION_BODY
+          ],
+          'A m(B b) {}',
+          failing: allExceptEof,
         ),
         new TestDescriptor(
           'type_noParams',
           'A m()',
-          [ParserErrorCode.EXPECTED_TOKEN],
-          'A m();',
-          allFailing: true,
+          [ParserErrorCode.MISSING_FUNCTION_BODY],
+          'A m() {}',
         ),
         new TestDescriptor(
           'type_params',
           'A m(b, c)',
-          [ParserErrorCode.EXPECTED_TOKEN],
-          'A m(b, c);',
-          allFailing: true,
+          [ParserErrorCode.MISSING_FUNCTION_BODY],
+          'A m(b, c) {}',
         ),
         new TestDescriptor(
           'type_emptyOptional',
@@ -147,50 +173,53 @@
         new TestDescriptor(
           'static_noType_leftParen',
           'static m(',
-          [ParserErrorCode.EXPECTED_TOKEN],
-          'static m();',
-          allFailing: true,
-          expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+          [
+            ScannerErrorCode.EXPECTED_TOKEN,
+            ParserErrorCode.MISSING_FUNCTION_BODY
+          ],
+          'static m() {}',
+          failing: allExceptEof,
         ),
         new TestDescriptor(
           'static_noType_paramName',
           'static m(B',
-          [ParserErrorCode.EXPECTED_TOKEN],
-          'static m(B);',
-          allFailing: true,
-          expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+          [
+            ScannerErrorCode.EXPECTED_TOKEN,
+            ParserErrorCode.MISSING_FUNCTION_BODY
+          ],
+          'static m(B) {}',
+          failing: ['methodNonVoid', 'getter', 'setter'],
         ),
         new TestDescriptor(
           'static_noType_paramTypeAndName',
           'static m(B b',
-          [ParserErrorCode.EXPECTED_TOKEN],
-          'static m(B b);',
-          allFailing: true,
-          expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+          [
+            ScannerErrorCode.EXPECTED_TOKEN,
+            ParserErrorCode.MISSING_FUNCTION_BODY
+          ],
+          'static m(B b) {}',
         ),
         new TestDescriptor(
           'static_noType_paramAndComma',
           'static m(B b,',
-          [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
-          'static m(B b, _s_);',
-          allFailing: true,
-          expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+          [
+            ScannerErrorCode.EXPECTED_TOKEN,
+            ParserErrorCode.MISSING_FUNCTION_BODY
+          ],
+          'static m(B b) {}',
+          failing: allExceptEof,
         ),
         new TestDescriptor(
           'static_noType_noParams',
           'static m()',
-          [ParserErrorCode.EXPECTED_TOKEN],
-          'static m();',
-          allFailing: true,
-          expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+          [ParserErrorCode.MISSING_FUNCTION_BODY],
+          'static m() {}',
         ),
         new TestDescriptor(
           'static_noType_params',
           'static m(b, c)',
-          [ParserErrorCode.EXPECTED_TOKEN],
-          'static m(b, c);',
-          allFailing: true,
-          expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+          [ParserErrorCode.MISSING_FUNCTION_BODY],
+          'static m(b, c) {}',
         ),
         new TestDescriptor(
           'static_noType_emptyOptional',
@@ -216,50 +245,53 @@
         new TestDescriptor(
           'static_type_leftParen',
           'static A m(',
-          [ParserErrorCode.EXPECTED_TOKEN],
-          'static A m();',
-          allFailing: true,
-          expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+          [
+            ScannerErrorCode.EXPECTED_TOKEN,
+            ParserErrorCode.MISSING_FUNCTION_BODY
+          ],
+          'static A m() {}',
+          failing: allExceptEof,
         ),
         new TestDescriptor(
           'static_type_paramName',
           'static A m(B',
-          [ParserErrorCode.EXPECTED_TOKEN],
-          'static A m(B);',
-          allFailing: true,
-          expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+          [
+            ScannerErrorCode.EXPECTED_TOKEN,
+            ParserErrorCode.MISSING_FUNCTION_BODY
+          ],
+          'static A m(B) {}',
+          failing: ['methodNonVoid', 'getter', 'setter'],
         ),
         new TestDescriptor(
           'static_type_paramTypeAndName',
           'static A m(B b',
-          [ParserErrorCode.EXPECTED_TOKEN],
-          'static A m(B b);',
-          allFailing: true,
-          expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+          [
+            ScannerErrorCode.EXPECTED_TOKEN,
+            ParserErrorCode.MISSING_FUNCTION_BODY
+          ],
+          'static A m(B b) {}',
         ),
         new TestDescriptor(
           'static_type_paramAndComma',
           'static A m(B b,',
-          [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
-          'static A m(B b, _s_);',
-          allFailing: true,
-          expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+          [
+            ScannerErrorCode.EXPECTED_TOKEN,
+            ParserErrorCode.MISSING_FUNCTION_BODY
+          ],
+          'static A m(B b) {}',
+          failing: allExceptEof,
         ),
         new TestDescriptor(
           'static_type_noParams',
           'static A m()',
-          [ParserErrorCode.EXPECTED_TOKEN],
-          'static A m();',
-          allFailing: true,
-          expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+          [ParserErrorCode.MISSING_FUNCTION_BODY],
+          'static A m() {}',
         ),
         new TestDescriptor(
           'static_type_params',
           'static A m(b, c)',
-          [ParserErrorCode.EXPECTED_TOKEN],
-          'static A m(b, c);',
-          allFailing: true,
-          expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+          [ParserErrorCode.MISSING_FUNCTION_BODY],
+          'static A m(b, c) {}',
         ),
         new TestDescriptor(
           'static_type_emptyOptional',
diff --git a/pkg/front_end/lib/src/fasta/parser/identifier_context.dart b/pkg/front_end/lib/src/fasta/parser/identifier_context.dart
index a4075e1..e0fdaec 100644
--- a/pkg/front_end/lib/src/fasta/parser/identifier_context.dart
+++ b/pkg/front_end/lib/src/fasta/parser/identifier_context.dart
@@ -60,9 +60,8 @@
 
   /// Identifier is a formal parameter being declared as part of a function,
   /// method, or typedef declaration.
-  static const formalParameterDeclaration = const IdentifierContext(
-      'formalParameterDeclaration',
-      inDeclaration: true);
+  static const formalParameterDeclaration =
+      const FormalParameterDeclarationIdentifierContext();
 
   /// Identifier is the start of a library name (e.g. `foo` in the directive
   /// 'library foo;`).
diff --git a/pkg/front_end/lib/src/fasta/parser/identifier_context_impl.dart b/pkg/front_end/lib/src/fasta/parser/identifier_context_impl.dart
index 2beb97c..18dd095 100644
--- a/pkg/front_end/lib/src/fasta/parser/identifier_context_impl.dart
+++ b/pkg/front_end/lib/src/fasta/parser/identifier_context_impl.dart
@@ -298,6 +298,39 @@
   }
 }
 
+/// See [IdentifierContext.formalParameterDeclaration].
+class FormalParameterDeclarationIdentifierContext extends IdentifierContext {
+  const FormalParameterDeclarationIdentifierContext()
+      : super('formalParameterDeclaration', inDeclaration: true);
+
+  @override
+  Token ensureIdentifier(Token token, Parser parser) {
+    Token identifier = token.next;
+    assert(identifier.kind != IDENTIFIER_TOKEN);
+    if (identifier.isIdentifier) {
+      return identifier;
+    }
+
+    // Recovery
+    const followingValues = const [':', '=', ',', '(', ')', '[', ']', '{', '}'];
+    if (looksLikeStartOfNextClassMember(identifier) ||
+        looksLikeStartOfNextStatement(identifier) ||
+        isOneOfOrEof(identifier, followingValues)) {
+      identifier = parser.insertSyntheticIdentifier(token, this,
+          message: fasta.templateExpectedIdentifier.withArguments(identifier));
+    } else {
+      parser.reportRecoverableErrorWithToken(
+          identifier, fasta.templateExpectedIdentifier);
+      if (!identifier.isKeywordOrIdentifier) {
+        // When in doubt, consume the token to ensure we make progress
+        // but insert a synthetic identifier to satisfy listeners.
+        identifier = parser.rewriter.insertSyntheticIdentifier(identifier);
+      }
+    }
+    return identifier;
+  }
+}
+
 /// See [IdentifierContext.importPrefixDeclaration].
 class ImportPrefixIdentifierContext extends IdentifierContext {
   const ImportPrefixIdentifierContext()
diff --git a/pkg/front_end/lib/src/fasta/parser/parser.dart b/pkg/front_end/lib/src/fasta/parser/parser.dart
index fc82a91..0264e50 100644
--- a/pkg/front_end/lib/src/fasta/parser/parser.dart
+++ b/pkg/front_end/lib/src/fasta/parser/parser.dart
@@ -1195,12 +1195,25 @@
       }
       token = parseFormalParameter(token, FormalParameterKind.mandatory, kind);
       next = token.next;
-      if (optional(',', next)) {
-        token = next;
-        continue;
+      if (!optional(',', next)) {
+        Token next = token.next;
+        if (optional(')', next)) {
+          token = next;
+        } else {
+          // Recovery
+          if (begin.endGroup.isSynthetic) {
+            // Scanner has already reported a missing `)` error,
+            // but placed the `)` in the wrong location, so move it.
+            token = rewriter.moveSynthetic(token, begin.endGroup);
+          } else {
+            reportRecoverableError(
+                next, fasta.templateExpectedButGot.withArguments(')'));
+            token = begin.endGroup;
+          }
+        }
+        break;
       }
-      token = ensureCloseParen(token, begin);
-      break;
+      token = next;
     }
     assert(optional(')', token));
     listener.endFormalParameters(parameterCount, begin, token, kind);
@@ -2013,8 +2026,6 @@
       followingValues = [';'];
     } else if (context == IdentifierContext.constructorReferenceContinuation) {
       followingValues = ['.', ',', '(', ')', '[', ']', '}', ';'];
-    } else if (context == IdentifierContext.formalParameterDeclaration) {
-      followingValues = [':', '=', ',', '(', ')', '[', ']', '{', '}'];
     } else if (context == IdentifierContext.labelDeclaration) {
       followingValues = [':'];
     } else if (context == IdentifierContext.literalSymbol ||
@@ -2041,8 +2052,6 @@
       return false;
     }
 
-    List<String> classMemberKeywords() =>
-        <String>['const', 'final', 'var', 'void'];
     List<String> statementKeywords() => <String>[
           'const',
           'do',
@@ -2054,19 +2063,6 @@
           'void',
           'while'
         ];
-    List<String> topLevelKeywords() => <String>[
-          'class',
-          'const',
-          'enum',
-          'export',
-          'final',
-          'import',
-          'library',
-          'part',
-          'typedef',
-          'var',
-          'void'
-        ];
 
     // TODO(brianwilkerson): At the moment, this test is entirely based on data
     // that can be represented declaratively. If that proves to be sufficient,
@@ -2074,12 +2070,7 @@
     // could create a method to test whether a given token matches one of the
     // patterns.
     List<String> initialKeywords;
-    if (context == IdentifierContext.formalParameterDeclaration) {
-      initialKeywords = topLevelKeywords()
-        ..addAll(classMemberKeywords())
-        ..addAll(statementKeywords())
-        ..add('covariant');
-    } else if (context == IdentifierContext.labelDeclaration) {
+    if (context == IdentifierContext.labelDeclaration) {
       initialKeywords = statementKeywords();
     } else if (context == IdentifierContext.localAccessorDeclaration) {
       initialKeywords = statementKeywords();