diff --git a/pkg/analyzer/lib/src/dart/analysis/search.dart b/pkg/analyzer/lib/src/dart/analysis/search.dart
index d1f7aa3..b51c2cf 100644
--- a/pkg/analyzer/lib/src/dart/analysis/search.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/search.dart
@@ -66,12 +66,11 @@
     }
 
     ElementKind kind = element.kind;
-    if (kind == ElementKind.CLASS ||
-        kind == ElementKind.CONSTRUCTOR ||
-        kind == ElementKind.ENUM ||
-        kind == ElementKind.EXTENSION ||
-        kind == ElementKind.FUNCTION_TYPE_ALIAS ||
-        kind == ElementKind.SETTER) {
+    if (element is ClassElement ||
+        element is ConstructorElement ||
+        element is ExtensionElement ||
+        element is PropertyAccessorElement && element.isSetter ||
+        element is TypeAliasElement) {
       return _searchReferences(element, searchedFiles);
     } else if (kind == ElementKind.COMPILATION_UNIT) {
       return _searchReferences_CompilationUnit(element);
diff --git a/pkg/analyzer/lib/src/test_utilities/find_element.dart b/pkg/analyzer/lib/src/test_utilities/find_element.dart
index 03153c0..2e8694b 100644
--- a/pkg/analyzer/lib/src/test_utilities/find_element.dart
+++ b/pkg/analyzer/lib/src/test_utilities/find_element.dart
@@ -72,6 +72,30 @@
     return ImportFindElement(import);
   }
 
+  LabelElement label(String name) {
+    LabelElement result;
+
+    void updateResult(Element element) {
+      if (element is LabelElement && element.name == name) {
+        if (result != null) {
+          throw StateError('Not unique: $name');
+        }
+        result = element;
+      }
+    }
+
+    unit.accept(FunctionAstVisitor(
+      label: (node) {
+        updateResult(node.label.staticElement);
+      },
+    ));
+
+    if (result == null) {
+      throw StateError('Not found: $name');
+    }
+    return result;
+  }
+
   FunctionElement localFunction(String name) {
     FunctionElement result;
 
diff --git a/pkg/analyzer/lib/src/test_utilities/function_ast_visitor.dart b/pkg/analyzer/lib/src/test_utilities/function_ast_visitor.dart
index 0c7d2ad..4fc84f6 100644
--- a/pkg/analyzer/lib/src/test_utilities/function_ast_visitor.dart
+++ b/pkg/analyzer/lib/src/test_utilities/function_ast_visitor.dart
@@ -11,6 +11,7 @@
   final void Function(FunctionDeclarationStatement)
       functionDeclarationStatement;
   final void Function(FunctionExpression, bool) functionExpression;
+  final void Function(Label) label;
   final void Function(SimpleIdentifier) simpleIdentifier;
   final void Function(VariableDeclaration) variableDeclaration;
 
@@ -18,6 +19,7 @@
     this.declaredIdentifier,
     this.functionDeclarationStatement,
     this.functionExpression,
+    this.label,
     this.simpleIdentifier,
     this.variableDeclaration,
   });
@@ -49,6 +51,14 @@
   }
 
   @override
+  void visitLabel(Label node) {
+    if (label != null) {
+      label(node);
+    }
+    super.visitLabel(node);
+  }
+
+  @override
   void visitSimpleIdentifier(SimpleIdentifier node) {
     if (simpleIdentifier != null) {
       simpleIdentifier(node);
diff --git a/pkg/analyzer/test/generated/class_member_parser_test.dart b/pkg/analyzer/test/generated/class_member_parser_test.dart
new file mode 100644
index 0000000..36f4c5d
--- /dev/null
+++ b/pkg/analyzer/test/generated/class_member_parser_test.dart
@@ -0,0 +1,1929 @@
+// Copyright (c) 2020, 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.
+
+import 'package:_fe_analyzer_shared/src/scanner/errors.dart';
+import 'package:analyzer/dart/analysis/features.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/src/dart/scanner/scanner.dart';
+import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../util/ast_type_matchers.dart';
+import 'parser_test_base.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(ClassMemberParserTest);
+  });
+}
+
+/// Tests which exercise the parser using a class member.
+@reflectiveTest
+class ClassMemberParserTest extends FastaParserTestCase
+    implements AbstractParserViaProxyTestCase {
+  final tripleShift = FeatureSet.forTesting(
+      sdkVersion: '2.0.0', additionalFeatures: [Feature.triple_shift]);
+
+  void test_parse_member_called_late() {
+    var unit = parseCompilationUnit(
+        'class C { void late() { new C().late(); } }',
+        featureSet: nonNullable);
+    var declaration = unit.declarations[0] as ClassDeclaration;
+    var method = declaration.members[0] as MethodDeclaration;
+
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name.name, 'late');
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+
+    var body = method.body as BlockFunctionBody;
+    var statement = body.block.statements[0] as ExpressionStatement;
+    var invocation = statement.expression as MethodInvocation;
+    expect(invocation.operator.lexeme, '.');
+    expect(invocation.toSource(), 'new C().late()');
+  }
+
+  void test_parseAwaitExpression_asStatement_inAsync() {
+    createParser('m() async { await x; }');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    FunctionBody body = method.body;
+    expect(body, isBlockFunctionBody);
+    Statement statement = (body as BlockFunctionBody).block.statements[0];
+    expect(statement, isExpressionStatement);
+    Expression expression = (statement as ExpressionStatement).expression;
+    expect(expression, isAwaitExpression);
+    expect((expression as AwaitExpression).awaitKeyword, isNotNull);
+    expect((expression as AwaitExpression).expression, isNotNull);
+  }
+
+  void test_parseAwaitExpression_asStatement_inSync() {
+    createParser('m() { await x; }');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    FunctionBody body = method.body;
+    expect(body, isBlockFunctionBody);
+    Statement statement = (body as BlockFunctionBody).block.statements[0];
+    expect(statement, isVariableDeclarationStatement);
+  }
+
+  void test_parseAwaitExpression_inSync() {
+    createParser('m() { return await x + await y; }');
+    MethodDeclaration method = parser.parseClassMember('C');
+    expect(method, isNotNull);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 13, 5),
+      expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 23, 5)
+    ]);
+    FunctionBody body = method.body;
+    expect(body, isBlockFunctionBody);
+    Statement statement = (body as BlockFunctionBody).block.statements[0];
+    expect(statement, isReturnStatement);
+    Expression expression = (statement as ReturnStatement).expression;
+    expect(expression, isBinaryExpression);
+  }
+
+  void test_parseClassMember_constructor_withDocComment() {
+    createParser('/// Doc\nC();');
+    var constructor = parser.parseClassMember('C') as ConstructorDeclaration;
+    expectCommentText(constructor.documentationComment, '/// Doc');
+  }
+
+  void test_parseClassMember_constructor_withInitializers() {
+    // TODO(brianwilkerson) Test other kinds of class members: fields, getters
+    // and setters.
+    createParser('C(_, _\$, this.__) : _a = _ + _\$ {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isConstructorDeclaration);
+    ConstructorDeclaration constructor = member;
+    expect(constructor.body, isNotNull);
+    expect(constructor.separator, isNotNull);
+    expect(constructor.externalKeyword, isNull);
+    expect(constructor.constKeyword, isNull);
+    expect(constructor.factoryKeyword, isNull);
+    expect(constructor.name, isNull);
+    expect(constructor.parameters, isNotNull);
+    expect(constructor.period, isNull);
+    expect(constructor.returnType, isNotNull);
+    expect(constructor.initializers, hasLength(1));
+  }
+
+  void test_parseClassMember_field_covariant() {
+    createParser('covariant T f;');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFieldDeclaration);
+    FieldDeclaration field = member;
+    expect(field.covariantKeyword, isNotNull);
+    expect(field.documentationComment, isNull);
+    expect(field.metadata, hasLength(0));
+    expect(field.staticKeyword, isNull);
+    VariableDeclarationList list = field.fields;
+    expect(list, isNotNull);
+    expect(list.keyword, isNull);
+    expect(list.isConst, isFalse);
+    expect(list.isFinal, isFalse);
+    expect(list.isLate, isFalse);
+    expect(list.lateKeyword, isNull);
+    NodeList<VariableDeclaration> variables = list.variables;
+    expect(variables, hasLength(1));
+    VariableDeclaration variable = variables[0];
+    expect(variable.name, isNotNull);
+  }
+
+  void test_parseClassMember_field_generic() {
+    createParser('List<List<N>> _allComponents = new List<List<N>>();');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFieldDeclaration);
+    FieldDeclaration field = member;
+    expect(field.covariantKeyword, isNull);
+    expect(field.documentationComment, isNull);
+    expect(field.metadata, hasLength(0));
+    expect(field.staticKeyword, isNull);
+    VariableDeclarationList list = field.fields;
+    expect(list, isNotNull);
+    expect(list, isNotNull);
+    expect(list.keyword, isNull);
+    expect(list.isConst, isFalse);
+    expect(list.isFinal, isFalse);
+    expect(list.isLate, isFalse);
+    expect(list.lateKeyword, isNull);
+    TypeName type = list.type;
+    expect(type.name.name, 'List');
+    NodeList typeArguments = type.typeArguments.arguments;
+    expect(typeArguments, hasLength(1));
+    TypeName type2 = typeArguments[0];
+    expect(type2.name.name, 'List');
+    NodeList typeArguments2 = type2.typeArguments.arguments;
+    expect(typeArguments2, hasLength(1));
+    TypeName type3 = typeArguments2[0];
+    expect(type3.name.name, 'N');
+    NodeList<VariableDeclaration> variables = list.variables;
+    expect(variables, hasLength(1));
+    VariableDeclaration variable = variables[0];
+    expect(variable.name, isNotNull);
+  }
+
+  void test_parseClassMember_field_gftType_gftReturnType() {
+    createParser('''
+Function(int) Function(String) v;
+''');
+    ClassMember member = parser.parseClassMember('C');
+    assertNoErrors();
+    expect(member, isFieldDeclaration);
+    VariableDeclarationList fields = (member as FieldDeclaration).fields;
+    expect(fields.type, isGenericFunctionType);
+  }
+
+  void test_parseClassMember_field_gftType_noReturnType() {
+    createParser('''
+Function(int, String) v;
+''');
+    ClassMember member = parser.parseClassMember('C');
+    assertNoErrors();
+    expect(member, isFieldDeclaration);
+    VariableDeclarationList fields = (member as FieldDeclaration).fields;
+    expect(fields.type, isGenericFunctionType);
+  }
+
+  void test_parseClassMember_field_instance_prefixedType() {
+    createParser('p.A f;');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFieldDeclaration);
+    FieldDeclaration field = member;
+    expect(field.covariantKeyword, isNull);
+    expect(field.documentationComment, isNull);
+    expect(field.metadata, hasLength(0));
+    expect(field.staticKeyword, isNull);
+    VariableDeclarationList list = field.fields;
+    expect(list, isNotNull);
+    expect(list, isNotNull);
+    expect(list.keyword, isNull);
+    expect(list.isConst, isFalse);
+    expect(list.isFinal, isFalse);
+    expect(list.isLate, isFalse);
+    expect(list.lateKeyword, isNull);
+    NodeList<VariableDeclaration> variables = list.variables;
+    expect(variables, hasLength(1));
+    VariableDeclaration variable = variables[0];
+    expect(variable.name, isNotNull);
+    _assertIsDeclarationName(variable.name);
+  }
+
+  void test_parseClassMember_field_namedGet() {
+    createParser('var get;');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFieldDeclaration);
+    FieldDeclaration field = member;
+    expect(field.covariantKeyword, isNull);
+    expect(field.documentationComment, isNull);
+    expect(field.metadata, hasLength(0));
+    expect(field.staticKeyword, isNull);
+    VariableDeclarationList list = field.fields;
+    expect(list, isNotNull);
+    expect(list, isNotNull);
+    expect(list.keyword, isNotNull);
+    expect(list.isConst, isFalse);
+    expect(list.isFinal, isFalse);
+    expect(list.isLate, isFalse);
+    expect(list.lateKeyword, isNull);
+    NodeList<VariableDeclaration> variables = list.variables;
+    expect(variables, hasLength(1));
+    VariableDeclaration variable = variables[0];
+    expect(variable.name, isNotNull);
+  }
+
+  void test_parseClassMember_field_namedOperator() {
+    createParser('var operator;');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFieldDeclaration);
+    FieldDeclaration field = member;
+    expect(field.covariantKeyword, isNull);
+    expect(field.documentationComment, isNull);
+    expect(field.metadata, hasLength(0));
+    expect(field.staticKeyword, isNull);
+    VariableDeclarationList list = field.fields;
+    expect(list, isNotNull);
+    expect(list, isNotNull);
+    expect(list.keyword, isNotNull);
+    expect(list.isConst, isFalse);
+    expect(list.isFinal, isFalse);
+    expect(list.isLate, isFalse);
+    expect(list.lateKeyword, isNull);
+    NodeList<VariableDeclaration> variables = list.variables;
+    expect(variables, hasLength(1));
+    VariableDeclaration variable = variables[0];
+    expect(variable.name, isNotNull);
+  }
+
+  void test_parseClassMember_field_namedOperator_withAssignment() {
+    createParser('var operator = (5);');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFieldDeclaration);
+    FieldDeclaration field = member;
+    expect(field.covariantKeyword, isNull);
+    expect(field.documentationComment, isNull);
+    expect(field.metadata, hasLength(0));
+    expect(field.staticKeyword, isNull);
+    VariableDeclarationList list = field.fields;
+    expect(list, isNotNull);
+    expect(list, isNotNull);
+    expect(list.keyword, isNotNull);
+    expect(list.isConst, isFalse);
+    expect(list.isFinal, isFalse);
+    expect(list.isLate, isFalse);
+    expect(list.lateKeyword, isNull);
+    NodeList<VariableDeclaration> variables = list.variables;
+    expect(variables, hasLength(1));
+    VariableDeclaration variable = variables[0];
+    expect(variable.name, isNotNull);
+    expect(variable.initializer, isNotNull);
+  }
+
+  void test_parseClassMember_field_namedSet() {
+    createParser('var set;');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFieldDeclaration);
+    FieldDeclaration field = member;
+    expect(field.covariantKeyword, isNull);
+    expect(field.documentationComment, isNull);
+    expect(field.metadata, hasLength(0));
+    expect(field.staticKeyword, isNull);
+    VariableDeclarationList list = field.fields;
+    expect(list, isNotNull);
+    expect(list, isNotNull);
+    expect(list.keyword, isNotNull);
+    expect(list.isConst, isFalse);
+    expect(list.isFinal, isFalse);
+    expect(list.isLate, isFalse);
+    expect(list.lateKeyword, isNull);
+    NodeList<VariableDeclaration> variables = list.variables;
+    expect(variables, hasLength(1));
+    VariableDeclaration variable = variables[0];
+    expect(variable.name, isNotNull);
+  }
+
+  void test_parseClassMember_field_nameKeyword() {
+    createParser('var for;');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD, 4, 3)
+    ]);
+  }
+
+  void test_parseClassMember_field_nameMissing() {
+    createParser('var ;');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 4, 1)]);
+  }
+
+  void test_parseClassMember_field_nameMissing2() {
+    createParser('var "";');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 4, 2)]);
+  }
+
+  void test_parseClassMember_field_static() {
+    createParser('static A f;');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFieldDeclaration);
+    FieldDeclaration field = member;
+    expect(field.covariantKeyword, isNull);
+    expect(field.documentationComment, isNull);
+    expect(field.metadata, hasLength(0));
+    expect(field.staticKeyword, isNotNull);
+    VariableDeclarationList list = field.fields;
+    expect(list, isNotNull);
+    expect(list, isNotNull);
+    expect(list.keyword, isNull);
+    expect(list.isConst, isFalse);
+    expect(list.isFinal, isFalse);
+    expect(list.isLate, isFalse);
+    expect(list.lateKeyword, isNull);
+    NodeList<VariableDeclaration> variables = list.variables;
+    expect(variables, hasLength(1));
+    VariableDeclaration variable = variables[0];
+    expect(variable.name, isNotNull);
+  }
+
+  void test_parseClassMember_finalAndCovariantLateWithInitializer() {
+    createParser(
+      'covariant late final int f = 0;',
+      featureSet: nonNullable,
+    );
+    parser.parseClassMember('C');
+    assertErrors(errors: [
+      expectedError(
+          ParserErrorCode.FINAL_AND_COVARIANT_LATE_WITH_INITIALIZER, 0, 9)
+    ]);
+  }
+
+  void test_parseClassMember_getter_functionType() {
+    createParser('int Function(int) get g {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    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_getter_void() {
+    createParser('void get g {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNotNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    _assertIsDeclarationName(method.name);
+    expect(method.operatorKeyword, isNull);
+    expect(method.body, isNotNull);
+    expect(method.parameters, isNull);
+  }
+
+  void test_parseClassMember_method_external() {
+    createParser('external m();');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNotNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.name, isNotNull);
+    _assertIsDeclarationName(method.name);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNull);
+
+    var body = method.body as EmptyFunctionBody;
+    expect(body.keyword, isNull);
+    expect(body.star, isNull);
+    expect(body.semicolon.type, TokenType.SEMICOLON);
+  }
+
+  void test_parseClassMember_method_external_withTypeAndArgs() {
+    createParser('external int m(int a);');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.body, isNotNull);
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNotNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+  }
+
+  void test_parseClassMember_method_generic_noReturnType() {
+    createParser('m<T>() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNotNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_generic_parameterType() {
+    createParser('m<T>(T p) => null;');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNotNull);
+
+    FormalParameterList parameters = method.parameters;
+    expect(parameters, isNotNull);
+    expect(parameters.parameters, hasLength(1));
+    var parameter = parameters.parameters[0] as SimpleFormalParameter;
+    var parameterType = parameter.type as TypeName;
+    expect(parameterType.name.name, 'T');
+
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_generic_returnType() {
+    createParser('T m<T>() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNotNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_generic_returnType_bound() {
+    createParser('T m<T extends num>() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect((method.returnType as TypeName).name.name, 'T');
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNotNull);
+    TypeParameter tp = method.typeParameters.typeParameters[0];
+    expect(tp.name.name, 'T');
+    expect(tp.extendsKeyword, isNotNull);
+    expect((tp.bound as TypeName).name.name, 'num');
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_generic_returnType_complex() {
+    createParser('Map<int, T> m<T>() => null;');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+
+    {
+      var returnType = method.returnType as TypeName;
+      expect(returnType, isNotNull);
+      expect(returnType.name.name, 'Map');
+
+      List<TypeAnnotation> typeArguments = returnType.typeArguments.arguments;
+      expect(typeArguments, hasLength(2));
+      expect((typeArguments[0] as TypeName).name.name, 'int');
+      expect((typeArguments[1] as TypeName).name.name, 'T');
+    }
+
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNotNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_generic_returnType_static() {
+    createParser('static T m<T>() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNotNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect((method.returnType as TypeName).name.name, 'T');
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNotNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_generic_void() {
+    createParser('void m<T>() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNotNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_get_noType() {
+    createParser('get() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_get_static_namedAsClass() {
+    createParser('static int get C => 0;');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.MEMBER_WITH_CLASS_NAME, 15, 1),
+    ]);
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNotNull);
+    expect(method.propertyKeyword, isNotNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_get_type() {
+    createParser('int get() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_get_void() {
+    createParser('void get() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_gftReturnType_noReturnType() {
+    createParser('''
+Function<A>(core.List<core.int> x) m() => null;
+''');
+    ClassMember member = parser.parseClassMember('C');
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    expect((member as MethodDeclaration).body, isExpressionFunctionBody);
+  }
+
+  void test_parseClassMember_method_gftReturnType_voidReturnType() {
+    createParser('''
+void Function<A>(core.List<core.int> x) m() => null;
+''');
+    ClassMember member = parser.parseClassMember('C');
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    expect((member as MethodDeclaration).body, isExpressionFunctionBody);
+  }
+
+  void test_parseClassMember_method_native_allowed() {
+    allowNativeClause = true;
+    _parseClassMember_method_native();
+    assertNoErrors();
+  }
+
+  void test_parseClassMember_method_native_missing_literal_allowed() {
+    allowNativeClause = true;
+    _parseClassMember_method_native_missing_literal();
+    assertNoErrors();
+  }
+
+  void test_parseClassMember_method_native_missing_literal_not_allowed() {
+    allowNativeClause = false;
+    _parseClassMember_method_native_missing_literal();
+    listener.assertErrors([
+      expectedError(ParserErrorCode.NATIVE_CLAUSE_SHOULD_BE_ANNOTATION, 4, 6),
+    ]);
+  }
+
+  void test_parseClassMember_method_native_not_allowed() {
+    allowNativeClause = false;
+    _parseClassMember_method_native();
+    listener.assertErrors([
+      expectedError(ParserErrorCode.NATIVE_CLAUSE_SHOULD_BE_ANNOTATION, 4, 6),
+    ]);
+  }
+
+  void test_parseClassMember_method_native_with_body_allowed() {
+    allowNativeClause = true;
+    _parseClassMember_method_native_with_body();
+    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
+    assertErrorsWithCodes([
+      ParserErrorCode.EXTERNAL_METHOD_WITH_BODY,
+    ]);
+//      listener.assertErrors([
+//        expectedError(ParserErrorCode.EXTERNAL_METHOD_WITH_BODY, 17, 2),
+//      ]);
+  }
+
+  void test_parseClassMember_method_native_with_body_not_allowed() {
+    allowNativeClause = false;
+    _parseClassMember_method_native_with_body();
+    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
+    assertErrorsWithCodes([
+      ParserErrorCode.NATIVE_CLAUSE_SHOULD_BE_ANNOTATION,
+      ParserErrorCode.EXTERNAL_METHOD_WITH_BODY,
+    ]);
+//      listener.assertErrors([
+//        expectedError(ParserErrorCode.NATIVE_CLAUSE_SHOULD_BE_ANNOTATION, 4, 6),
+//        expectedError(ParserErrorCode.EXTERNAL_METHOD_WITH_BODY, 17, 2),
+//      ]);
+  }
+
+  void test_parseClassMember_method_operator_noType() {
+    createParser('operator() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_operator_type() {
+    createParser('int operator() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_operator_void() {
+    createParser('void operator() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_returnType_functionType() {
+    createParser('int Function(String) m() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    expect(method.name.name, 'm');
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_returnType_parameterized() {
+    createParser('p.A m() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_set_noType() {
+    createParser('set() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_set_static_namedAsClass() {
+    createParser('static void set C(_) {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.MEMBER_WITH_CLASS_NAME, 16, 1),
+    ]);
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNotNull);
+    expect(method.propertyKeyword, isNotNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_set_type() {
+    createParser('int set() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_set_void() {
+    createParser('void set() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_static_class() {
+    var unit = parseCompilationUnit('class C { static void m() {} }');
+
+    ClassDeclaration c = unit.declarations[0];
+    MethodDeclaration method = c.members[0];
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNotNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_static_mixin() {
+    var unit = parseCompilationUnit('mixin C { static void m() {} }');
+    MixinDeclaration c = unit.declarations[0];
+    MethodDeclaration method = c.members[0];
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNotNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_method_trailing_commas() {
+    createParser('void f(int x, int y,) {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_operator_functionType() {
+    createParser('int Function() operator +(int Function() f) {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isGenericFunctionType);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNotNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    NodeList<FormalParameter> parameters = method.parameters.parameters;
+    expect(parameters, hasLength(1));
+    expect(
+        (parameters[0] as SimpleFormalParameter).type, isGenericFunctionType);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_operator_gtgtgt() {
+    var unit = parseCompilationUnit(
+        'class C { bool operator >>>(other) => false; }',
+        featureSet: tripleShift);
+    var declaration = unit.declarations[0] as ClassDeclaration;
+    var method = declaration.members[0] as MethodDeclaration;
+
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name.name, '>>>');
+    expect(method.operatorKeyword, isNotNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_operator_gtgtgteq() {
+    var unit = parseCompilationUnit(
+        'class C { foo(int value) { x >>>= value; } }',
+        featureSet: tripleShift);
+    var declaration = unit.declarations[0] as ClassDeclaration;
+    var method = declaration.members[0] as MethodDeclaration;
+    var blockFunctionBody = method.body as BlockFunctionBody;
+    NodeList<Statement> statements = blockFunctionBody.block.statements;
+    expect(statements, hasLength(1));
+    var statement = statements[0] as ExpressionStatement;
+    var assignment = statement.expression as AssignmentExpression;
+    var leftHandSide = assignment.leftHandSide as SimpleIdentifier;
+    expect(leftHandSide.name, 'x');
+    expect(assignment.operator.lexeme, '>>>=');
+    var rightHandSide = assignment.rightHandSide as SimpleIdentifier;
+    expect(rightHandSide.name, 'value');
+  }
+
+  void test_parseClassMember_operator_index() {
+    createParser('int operator [](int i) {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNotNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_operator_indexAssign() {
+    createParser('int operator []=(int i) {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNotNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_operator_lessThan() {
+    createParser('bool operator <(other) => false;');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name.name, '<');
+    expect(method.operatorKeyword, isNotNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.body, isNotNull);
+  }
+
+  void test_parseClassMember_redirectingFactory_const() {
+    createParser('const factory C() = prefix.B.foo;');
+    var constructor = parser.parseClassMember('C') as ConstructorDeclaration;
+    assertNoErrors();
+    expect(constructor, isNotNull);
+    expect(constructor.externalKeyword, isNull);
+    expect(constructor.constKeyword.keyword, Keyword.CONST);
+    expect(constructor.factoryKeyword.keyword, Keyword.FACTORY);
+    expect(constructor.returnType.name, 'C');
+    expect(constructor.period, isNull);
+    expect(constructor.name, isNull);
+    _assertIsDeclarationName(constructor.returnType, false);
+    expect(constructor.parameters, isNotNull);
+    expect(constructor.parameters.parameters, isEmpty);
+    expect(constructor.separator.type, TokenType.EQ);
+    expect(constructor.initializers, isEmpty);
+    expect(constructor.redirectedConstructor, isNotNull);
+    expect(constructor.redirectedConstructor.type.name.name, 'prefix.B');
+    expect(constructor.redirectedConstructor.period.type, TokenType.PERIOD);
+    expect(constructor.redirectedConstructor.name.name, 'foo');
+    expect(constructor.body, isEmptyFunctionBody);
+  }
+
+  void test_parseClassMember_redirectingFactory_expressionBody() {
+    createParser('factory C() => throw 0;');
+    var constructor = parser.parseClassMember('C') as ConstructorDeclaration;
+    assertNoErrors();
+    expect(constructor, isNotNull);
+    expect(constructor.externalKeyword, isNull);
+    expect(constructor.constKeyword, isNull);
+    expect(constructor.factoryKeyword.keyword, Keyword.FACTORY);
+    expect(constructor.returnType.name, 'C');
+    expect(constructor.period, isNull);
+    expect(constructor.name, isNull);
+    expect(constructor.parameters, isNotNull);
+    expect(constructor.parameters.parameters, isEmpty);
+    expect(constructor.separator, isNull);
+    expect(constructor.initializers, isEmpty);
+    expect(constructor.redirectedConstructor, isNull);
+
+    var body = constructor.body as ExpressionFunctionBody;
+    expect(body.keyword, isNull);
+    expect(body.star, isNull);
+    expect(body.functionDefinition.type, TokenType.FUNCTION);
+    expect(body.expression, isNotNull);
+    expect(body.semicolon, isNotNull);
+  }
+
+  void test_parseClassMember_redirectingFactory_nonConst() {
+    createParser('factory C() = B;');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isConstructorDeclaration);
+    ConstructorDeclaration constructor = member;
+    expect(constructor.externalKeyword, isNull);
+    expect(constructor.constKeyword, isNull);
+    expect(constructor.factoryKeyword.keyword, Keyword.FACTORY);
+    expect(constructor.returnType.name, 'C');
+    _assertIsDeclarationName(constructor.returnType, false);
+    expect(constructor.period, isNull);
+    expect(constructor.name, isNull);
+    expect(constructor.parameters, isNotNull);
+    expect(constructor.parameters.parameters, isEmpty);
+    expect(constructor.separator.type, TokenType.EQ);
+    expect(constructor.initializers, isEmpty);
+    expect(constructor.redirectedConstructor, isNotNull);
+    expect(constructor.redirectedConstructor.type.name.name, 'B');
+    expect(constructor.redirectedConstructor.period, isNull);
+    expect(constructor.redirectedConstructor.name, isNull);
+    expect(constructor.body, isEmptyFunctionBody);
+  }
+
+  void test_parseConstructor_assert() {
+    createParser('C(x, y) : _x = x, assert (x < y), _y = y;');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isConstructorDeclaration);
+    ConstructorDeclaration constructor = member as ConstructorDeclaration;
+    NodeList<ConstructorInitializer> initializers = constructor.initializers;
+    expect(initializers, hasLength(3));
+    ConstructorInitializer initializer = initializers[1];
+    expect(initializer, isAssertInitializer);
+    AssertInitializer assertInitializer = initializer;
+    expect(assertInitializer.condition, isNotNull);
+    expect(assertInitializer.message, isNull);
+  }
+
+  void test_parseConstructor_factory_const_external() {
+    // Although the spec does not allow external const factory,
+    // there are several instances of this in the Dart SDK.
+    // For example `external const factory bool.fromEnvironment(...)`.
+    createParser('external const factory C();');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    assertNoErrors();
+  }
+
+  void test_parseConstructor_factory_named() {
+    createParser('factory C.foo() => throw 0;');
+    var constructor = parser.parseClassMember('C') as ConstructorDeclaration;
+    assertNoErrors();
+    expect(constructor, isNotNull);
+    expect(constructor.externalKeyword, isNull);
+    expect(constructor.constKeyword, isNull);
+    expect(constructor.factoryKeyword, isNotNull);
+    expect(constructor.returnType.name, 'C');
+    _assertIsDeclarationName(constructor.returnType, false);
+    expect(constructor.period.type, TokenType.PERIOD);
+    expect(constructor.name.name, 'foo');
+    _assertIsDeclarationName(constructor.name);
+    expect(constructor.parameters, isNotNull);
+    expect(constructor.parameters.parameters, isEmpty);
+    expect(constructor.separator, isNull);
+    expect(constructor.initializers, isEmpty);
+    expect(constructor.redirectedConstructor, isNull);
+    expect(constructor.body, isExpressionFunctionBody);
+  }
+
+  void test_parseConstructor_initializers_field() {
+    createParser('C(x, y) : _x = x, this._y = y;');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isConstructorDeclaration);
+    ConstructorDeclaration constructor = member as ConstructorDeclaration;
+    NodeList<ConstructorInitializer> initializers = constructor.initializers;
+    expect(initializers, hasLength(2));
+
+    {
+      var initializer = initializers[0] as ConstructorFieldInitializer;
+      expect(initializer.thisKeyword, isNull);
+      expect(initializer.period, isNull);
+      expect(initializer.fieldName.name, '_x');
+      expect(initializer.expression, isNotNull);
+    }
+
+    {
+      var initializer = initializers[1] as ConstructorFieldInitializer;
+      expect(initializer.thisKeyword, isNotNull);
+      expect(initializer.period, isNotNull);
+      expect(initializer.fieldName.name, '_y');
+      expect(initializer.expression, isNotNull);
+    }
+  }
+
+  void test_parseConstructor_invalidInitializer() {
+    // https://github.com/dart-lang/sdk/issues/37693
+    parseCompilationUnit('class C{ C() : super() * (); }', errors: [
+      expectedError(ParserErrorCode.INVALID_INITIALIZER, 15, 12),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 26, 1),
+    ]);
+  }
+
+  void test_parseConstructor_named() {
+    createParser('C.foo();');
+    var constructor = parser.parseClassMember('C') as ConstructorDeclaration;
+    assertNoErrors();
+    expect(constructor, isNotNull);
+    expect(constructor.externalKeyword, isNull);
+    expect(constructor.constKeyword, isNull);
+    expect(constructor.factoryKeyword, isNull);
+    expect(constructor.returnType.name, 'C');
+    _assertIsDeclarationName(constructor.returnType, false);
+    expect(constructor.period.type, TokenType.PERIOD);
+    expect(constructor.name.name, 'foo');
+    _assertIsDeclarationName(constructor.name);
+    expect(constructor.parameters, isNotNull);
+    expect(constructor.parameters.parameters, isEmpty);
+    expect(constructor.separator, isNull);
+    expect(constructor.initializers, isEmpty);
+    expect(constructor.redirectedConstructor, isNull);
+    expect(constructor.body, isEmptyFunctionBody);
+  }
+
+  void test_parseConstructor_nullSuperArgList_openBrace_37735() {
+    // https://github.com/dart-lang/sdk/issues/37735
+    var unit = parseCompilationUnit('class{const():super.{n', errors: [
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 5, 1),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 11, 1),
+      expectedError(ParserErrorCode.INVALID_CONSTRUCTOR_NAME, 11, 1),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 20, 1),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 20, 1),
+      expectedError(ParserErrorCode.CONST_CONSTRUCTOR_WITH_BODY, 20, 1),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 21, 1),
+      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 22, 1),
+      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 22, 1),
+    ]);
+    var classDeclaration = unit.declarations[0] as ClassDeclaration;
+    var constructor = classDeclaration.members[0] as ConstructorDeclaration;
+    var invocation = constructor.initializers[0] as SuperConstructorInvocation;
+    expect(invocation.argumentList.arguments, hasLength(0));
+  }
+
+  void test_parseConstructor_operator_name() {
+    var unit = parseCompilationUnit('class A { operator/() : super(); }',
+        errors: [
+          expectedError(ParserErrorCode.INVALID_CONSTRUCTOR_NAME, 10, 8)
+        ]);
+    var classDeclaration = unit.declarations[0] as ClassDeclaration;
+    var constructor = classDeclaration.members[0] as ConstructorDeclaration;
+    var invocation = constructor.initializers[0] as SuperConstructorInvocation;
+    expect(invocation.argumentList.arguments, hasLength(0));
+  }
+
+  void test_parseConstructor_superIndexed() {
+    createParser('C() : super()[];');
+    var constructor = parser.parseClassMember('C') as ConstructorDeclaration;
+    listener.assertErrors([
+      expectedError(ParserErrorCode.INVALID_SUPER_IN_INITIALIZER, 6, 5),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 14, 1),
+    ]);
+    expect(constructor, isNotNull);
+    expect(constructor.externalKeyword, isNull);
+    expect(constructor.constKeyword, isNull);
+    expect(constructor.factoryKeyword, isNull);
+    expect(constructor.returnType.name, 'C');
+    _assertIsDeclarationName(constructor.returnType, false);
+    expect(constructor.name, isNull);
+    expect(constructor.parameters, isNotNull);
+    expect(constructor.parameters.parameters, isEmpty);
+    expect(constructor.separator.lexeme, ':');
+    expect(constructor.initializers, hasLength(1));
+    SuperConstructorInvocation initializer = constructor.initializers[0];
+    expect(initializer.argumentList.arguments, isEmpty);
+    expect(constructor.redirectedConstructor, isNull);
+    expect(constructor.body, isEmptyFunctionBody);
+  }
+
+  void test_parseConstructor_thisIndexed() {
+    createParser('C() : this()[];');
+    var constructor = parser.parseClassMember('C') as ConstructorDeclaration;
+    listener.assertErrors([
+      expectedError(ParserErrorCode.INVALID_THIS_IN_INITIALIZER, 6, 4),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 13, 1),
+    ]);
+    expect(constructor, isNotNull);
+    expect(constructor.externalKeyword, isNull);
+    expect(constructor.constKeyword, isNull);
+    expect(constructor.factoryKeyword, isNull);
+    expect(constructor.returnType.name, 'C');
+    _assertIsDeclarationName(constructor.returnType, false);
+    expect(constructor.name, isNull);
+    expect(constructor.parameters, isNotNull);
+    expect(constructor.parameters.parameters, isEmpty);
+    expect(constructor.separator.lexeme, ':');
+    expect(constructor.initializers, hasLength(1));
+    RedirectingConstructorInvocation initializer = constructor.initializers[0];
+    expect(initializer.argumentList.arguments, isEmpty);
+    expect(constructor.redirectedConstructor, isNull);
+    expect(constructor.body, isEmptyFunctionBody);
+  }
+
+  void test_parseConstructor_unnamed() {
+    createParser('C();');
+    var constructor = parser.parseClassMember('C') as ConstructorDeclaration;
+    assertNoErrors();
+    expect(constructor, isNotNull);
+    expect(constructor.externalKeyword, isNull);
+    expect(constructor.constKeyword, isNull);
+    expect(constructor.factoryKeyword, isNull);
+    expect(constructor.returnType.name, 'C');
+    _assertIsDeclarationName(constructor.returnType, false);
+    expect(constructor.period, isNull);
+    expect(constructor.name, isNull);
+    expect(constructor.parameters, isNotNull);
+    expect(constructor.parameters.parameters, isEmpty);
+    expect(constructor.separator, isNull);
+    expect(constructor.initializers, isEmpty);
+    expect(constructor.redirectedConstructor, isNull);
+    expect(constructor.body, isEmptyFunctionBody);
+  }
+
+  void test_parseConstructor_with_pseudo_function_literal() {
+    // "(b) {}" should not be misinterpreted as a function literal even though
+    // it looks like one.
+    createParser('C() : a = (b) {}');
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isConstructorDeclaration);
+    ConstructorDeclaration constructor = member as ConstructorDeclaration;
+    NodeList<ConstructorInitializer> initializers = constructor.initializers;
+    expect(initializers, hasLength(1));
+    ConstructorInitializer initializer = initializers[0];
+    expect(initializer, isConstructorFieldInitializer);
+    expect((initializer as ConstructorFieldInitializer).expression,
+        isParenthesizedExpression);
+    expect(constructor.body, isBlockFunctionBody);
+  }
+
+  void test_parseConstructorFieldInitializer_qualified() {
+    var initializer = parseConstructorInitializer('this.a = b')
+        as ConstructorFieldInitializer;
+    expect(initializer, isNotNull);
+    assertNoErrors();
+    expect(initializer.equals, isNotNull);
+    expect(initializer.expression, isNotNull);
+    expect(initializer.fieldName, isNotNull);
+    expect(initializer.thisKeyword, isNotNull);
+    expect(initializer.period, isNotNull);
+  }
+
+  void test_parseConstructorFieldInitializer_unqualified() {
+    var initializer =
+        parseConstructorInitializer('a = b') as ConstructorFieldInitializer;
+    expect(initializer, isNotNull);
+    assertNoErrors();
+    expect(initializer.equals, isNotNull);
+    expect(initializer.expression, isNotNull);
+    expect(initializer.fieldName, isNotNull);
+    expect(initializer.thisKeyword, isNull);
+    expect(initializer.period, isNull);
+  }
+
+  void test_parseField_abstract() {
+    createParser('abstract int i;', featureSet: nonNullable);
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFieldDeclaration);
+    var field = member as FieldDeclaration;
+    expect(field.abstractKeyword, isNotNull);
+  }
+
+  void test_parseField_abstract_external() {
+    createParser('abstract external int i;', featureSet: nonNullable);
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertErrors(errors: [
+      expectedError(ParserErrorCode.ABSTRACT_EXTERNAL_FIELD, 0, 8),
+    ]);
+    expect(member, isFieldDeclaration);
+    var field = member as FieldDeclaration;
+    expect(field.abstractKeyword, isNotNull);
+    expect(field.externalKeyword, isNotNull);
+  }
+
+  void test_parseField_abstract_late() {
+    createParser('abstract late int? i;', featureSet: nonNullable);
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertErrors(errors: [
+      expectedError(ParserErrorCode.ABSTRACT_LATE_FIELD, 0, 8),
+    ]);
+    expect(member, isFieldDeclaration);
+    var field = member as FieldDeclaration;
+    expect(field.abstractKeyword, isNotNull);
+  }
+
+  void test_parseField_abstract_late_final() {
+    createParser('abstract late final int? i;', featureSet: nonNullable);
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertErrors(errors: [
+      expectedError(ParserErrorCode.ABSTRACT_LATE_FIELD, 0, 8),
+    ]);
+    expect(member, isFieldDeclaration);
+    var field = member as FieldDeclaration;
+    expect(field.abstractKeyword, isNotNull);
+  }
+
+  void test_parseField_abstract_static() {
+    createParser('abstract static int? i;', featureSet: nonNullable);
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertErrors(errors: [
+      expectedError(ParserErrorCode.ABSTRACT_STATIC_FIELD, 0, 8),
+    ]);
+    expect(member, isFieldDeclaration);
+    var field = member as FieldDeclaration;
+    expect(field.abstractKeyword, isNotNull);
+  }
+
+  void test_parseField_const_late() {
+    createParser('const late T f = 0;', featureSet: nonNullable);
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertErrors(errors: [
+      expectedError(ParserErrorCode.CONFLICTING_MODIFIERS, 6, 4),
+    ]);
+    expect(member, isFieldDeclaration);
+    var field = member as FieldDeclaration;
+    expect(field.covariantKeyword, isNull);
+    expect(field.documentationComment, isNull);
+    expect(field.metadata, hasLength(0));
+    expect(field.staticKeyword, isNull);
+    VariableDeclarationList list = field.fields;
+    expect(list, isNotNull);
+    expect(list.keyword, isNotNull);
+    expect(list.isConst, isTrue);
+    expect(list.isFinal, isFalse);
+    expect(list.isLate, isTrue);
+    expect(list.lateKeyword, isNotNull);
+    NodeList<VariableDeclaration> variables = list.variables;
+    expect(variables, hasLength(1));
+    VariableDeclaration variable = variables[0];
+    expect(variable.name, isNotNull);
+  }
+
+  void test_parseField_external() {
+    createParser('external int i;', featureSet: nonNullable);
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFieldDeclaration);
+    var field = member as FieldDeclaration;
+    expect(field.externalKeyword, isNotNull);
+  }
+
+  void test_parseField_external_abstract() {
+    createParser('external abstract int i;', featureSet: nonNullable);
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertErrors(errors: [
+      expectedError(ParserErrorCode.ABSTRACT_EXTERNAL_FIELD, 9, 8),
+    ]);
+    expect(member, isFieldDeclaration);
+    var field = member as FieldDeclaration;
+    expect(field.abstractKeyword, isNotNull);
+    expect(field.externalKeyword, isNotNull);
+  }
+
+  void test_parseField_external_late() {
+    createParser('external late int? i;', featureSet: nonNullable);
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertErrors(errors: [
+      expectedError(ParserErrorCode.EXTERNAL_LATE_FIELD, 0, 8),
+    ]);
+    expect(member, isFieldDeclaration);
+    var field = member as FieldDeclaration;
+    expect(field.externalKeyword, isNotNull);
+  }
+
+  void test_parseField_external_late_final() {
+    createParser('external late final int? i;', featureSet: nonNullable);
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertErrors(errors: [
+      expectedError(ParserErrorCode.EXTERNAL_LATE_FIELD, 0, 8),
+    ]);
+    expect(member, isFieldDeclaration);
+    var field = member as FieldDeclaration;
+    expect(field.externalKeyword, isNotNull);
+  }
+
+  void test_parseField_external_static() {
+    createParser('external static int? i;', featureSet: nonNullable);
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFieldDeclaration);
+    var field = member as FieldDeclaration;
+    expect(field.externalKeyword, isNotNull);
+  }
+
+  void test_parseField_final_late() {
+    createParser('final late T f;', featureSet: nonNullable);
+    ClassMember member = parser.parseClassMember('C');
+    assertErrors(errors: [
+      expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 6, 4),
+    ]);
+    expect(member, isNotNull);
+    expect(member, isFieldDeclaration);
+    var field = member as FieldDeclaration;
+    expect(field.covariantKeyword, isNull);
+    expect(field.documentationComment, isNull);
+    expect(field.metadata, hasLength(0));
+    expect(field.staticKeyword, isNull);
+    VariableDeclarationList list = field.fields;
+    expect(list, isNotNull);
+    expect(list.keyword, isNotNull);
+    expect(list.isConst, isFalse);
+    expect(list.isFinal, isTrue);
+    expect(list.isLate, isTrue);
+    expect(list.lateKeyword, isNotNull);
+    NodeList<VariableDeclaration> variables = list.variables;
+    expect(variables, hasLength(1));
+    VariableDeclaration variable = variables[0];
+    expect(variable.name, isNotNull);
+  }
+
+  void test_parseField_late() {
+    createParser('late T f;', featureSet: nonNullable);
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFieldDeclaration);
+    var field = member as FieldDeclaration;
+    expect(field.covariantKeyword, isNull);
+    expect(field.documentationComment, isNull);
+    expect(field.metadata, hasLength(0));
+    expect(field.staticKeyword, isNull);
+    VariableDeclarationList list = field.fields;
+    expect(list, isNotNull);
+    expect(list.keyword, isNull);
+    expect(list.isConst, isFalse);
+    expect(list.isFinal, isFalse);
+    expect(list.isLate, isTrue);
+    expect(list.lateKeyword, isNotNull);
+    NodeList<VariableDeclaration> variables = list.variables;
+    expect(variables, hasLength(1));
+    VariableDeclaration variable = variables[0];
+    expect(variable.name, isNotNull);
+  }
+
+  void test_parseField_late_const() {
+    createParser('late const T f = 0;', featureSet: nonNullable);
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertErrors(errors: [
+      expectedError(ParserErrorCode.CONFLICTING_MODIFIERS, 5, 5),
+    ]);
+    expect(member, isFieldDeclaration);
+    var field = member as FieldDeclaration;
+    expect(field.covariantKeyword, isNull);
+    expect(field.documentationComment, isNull);
+    expect(field.metadata, hasLength(0));
+    expect(field.staticKeyword, isNull);
+    VariableDeclarationList list = field.fields;
+    expect(list, isNotNull);
+    expect(list.keyword, isNotNull);
+    expect(list.isConst, isTrue);
+    expect(list.isFinal, isFalse);
+    expect(list.isLate, isTrue);
+    expect(list.lateKeyword, isNotNull);
+    NodeList<VariableDeclaration> variables = list.variables;
+    expect(variables, hasLength(1));
+    VariableDeclaration variable = variables[0];
+    expect(variable.name, isNotNull);
+  }
+
+  void test_parseField_late_final() {
+    createParser('late final T f;', featureSet: nonNullable);
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFieldDeclaration);
+    var field = member as FieldDeclaration;
+    expect(field.covariantKeyword, isNull);
+    expect(field.documentationComment, isNull);
+    expect(field.metadata, hasLength(0));
+    expect(field.staticKeyword, isNull);
+    VariableDeclarationList list = field.fields;
+    expect(list, isNotNull);
+    expect(list.keyword, isNotNull);
+    expect(list.isConst, isFalse);
+    expect(list.isFinal, isTrue);
+    expect(list.isLate, isTrue);
+    expect(list.lateKeyword, isNotNull);
+    NodeList<VariableDeclaration> variables = list.variables;
+    expect(variables, hasLength(1));
+    VariableDeclaration variable = variables[0];
+    expect(variable.name, isNotNull);
+  }
+
+  void test_parseField_late_var() {
+    createParser('late var f;', featureSet: nonNullable);
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    expect(member, isFieldDeclaration);
+    var field = member as FieldDeclaration;
+    expect(field.covariantKeyword, isNull);
+    expect(field.documentationComment, isNull);
+    expect(field.metadata, hasLength(0));
+    expect(field.staticKeyword, isNull);
+    VariableDeclarationList list = field.fields;
+    expect(list, isNotNull);
+    expect(list.keyword, isNotNull);
+    expect(list.isConst, isFalse);
+    expect(list.isFinal, isFalse);
+    expect(list.isLate, isTrue);
+    expect(list.lateKeyword, isNotNull);
+    NodeList<VariableDeclaration> variables = list.variables;
+    expect(variables, hasLength(1));
+    VariableDeclaration variable = variables[0];
+    expect(variable.name, isNotNull);
+  }
+
+  void test_parseField_non_abstract() {
+    createParser('int i;', featureSet: nonNullable);
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFieldDeclaration);
+    var field = member as FieldDeclaration;
+    expect(field.abstractKeyword, isNull);
+  }
+
+  void test_parseField_non_external() {
+    createParser('int i;', featureSet: nonNullable);
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFieldDeclaration);
+    var field = member as FieldDeclaration;
+    expect(field.externalKeyword, isNull);
+  }
+
+  void test_parseField_var_late() {
+    createParser('var late f;', featureSet: nonNullable);
+    ClassMember member = parser.parseClassMember('C');
+    expect(member, isNotNull);
+    assertErrors(errors: [
+      expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 4, 4),
+    ]);
+    expect(member, isFieldDeclaration);
+    var field = member as FieldDeclaration;
+    expect(field.covariantKeyword, isNull);
+    expect(field.documentationComment, isNull);
+    expect(field.metadata, hasLength(0));
+    expect(field.staticKeyword, isNull);
+    VariableDeclarationList list = field.fields;
+    expect(list, isNotNull);
+    expect(list.keyword, isNotNull);
+    expect(list.isConst, isFalse);
+    expect(list.isFinal, isFalse);
+    expect(list.isLate, isTrue);
+    expect(list.lateKeyword, isNotNull);
+    NodeList<VariableDeclaration> variables = list.variables;
+    expect(variables, hasLength(1));
+    VariableDeclaration variable = variables[0];
+    expect(variable.name, isNotNull);
+  }
+
+  void test_parseGetter_identifier_colon_issue_36961() {
+    createParser('get a:');
+    ConstructorDeclaration constructor = parser.parseClassMember('C');
+    expect(constructor, isNotNull);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.GETTER_CONSTRUCTOR, 0, 3),
+      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 4, 1),
+      expectedError(ParserErrorCode.INVALID_CONSTRUCTOR_NAME, 4, 1),
+      expectedError(ParserErrorCode.MISSING_INITIALIZER, 5, 1),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 6, 0),
+    ]);
+    expect(constructor.body, isNotNull);
+    expect(constructor.documentationComment, isNull);
+    expect(constructor.externalKeyword, isNull);
+    expect(constructor.name, isNull);
+    expect(constructor.parameters, isNotNull);
+    expect(constructor.returnType, isNotNull);
+  }
+
+  void test_parseGetter_nonStatic() {
+    createParser('/// Doc\nT get a;');
+    MethodDeclaration method = parser.parseClassMember('C');
+    expect(method, isNotNull);
+    assertNoErrors();
+    expect(method.body, isNotNull);
+    expectCommentText(method.documentationComment, '/// Doc');
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.parameters, isNull);
+    expect(method.propertyKeyword, isNotNull);
+    expect((method.returnType as TypeName).name.name, 'T');
+  }
+
+  void test_parseGetter_static() {
+    createParser('/// Doc\nstatic T get a => 42;');
+    MethodDeclaration method = parser.parseClassMember('C');
+    expect(method, isNotNull);
+    assertNoErrors();
+    expect(method.body, isNotNull);
+    expectCommentText(method.documentationComment, '/// Doc');
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword.lexeme, 'static');
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNull);
+    expect(method.propertyKeyword, isNotNull);
+    expect((method.returnType as TypeName).name.name, 'T');
+  }
+
+  void test_parseInitializedIdentifierList_type() {
+    createParser("/// Doc\nstatic T a = 1, b, c = 3;");
+    FieldDeclaration declaration = parser.parseClassMember('C');
+    expect(declaration, isNotNull);
+    assertNoErrors();
+    expectCommentText(declaration.documentationComment, '/// Doc');
+    VariableDeclarationList fields = declaration.fields;
+    expect(fields, isNotNull);
+    expect(fields.keyword, isNull);
+    expect((fields.type as TypeName).name.name, 'T');
+    expect(fields.variables, hasLength(3));
+    expect(declaration.staticKeyword.lexeme, 'static');
+    expect(declaration.semicolon, isNotNull);
+  }
+
+  void test_parseInitializedIdentifierList_var() {
+    createParser('/// Doc\nstatic var a = 1, b, c = 3;');
+    FieldDeclaration declaration = parser.parseClassMember('C');
+    expect(declaration, isNotNull);
+    assertNoErrors();
+    expectCommentText(declaration.documentationComment, '/// Doc');
+    VariableDeclarationList fields = declaration.fields;
+    expect(fields, isNotNull);
+    expect(fields.keyword.lexeme, 'var');
+    expect(fields.type, isNull);
+    expect(fields.variables, hasLength(3));
+    expect(declaration.staticKeyword.lexeme, 'static');
+    expect(declaration.semicolon, isNotNull);
+  }
+
+  void test_parseOperator() {
+    createParser('/// Doc\nT operator +(A a);');
+    MethodDeclaration method = parser.parseClassMember('C');
+    expect(method, isNotNull);
+    assertNoErrors();
+    expect(method.body, isNotNull);
+    expectCommentText(method.documentationComment, '/// Doc');
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNotNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.propertyKeyword, isNull);
+    expect((method.returnType as TypeName).name.name, 'T');
+  }
+
+  void test_parseSetter_nonStatic() {
+    createParser('/// Doc\nT set a(var x);');
+    MethodDeclaration method = parser.parseClassMember('C');
+    expect(method, isNotNull);
+    assertNoErrors();
+    expect(method.body, isNotNull);
+    expectCommentText(method.documentationComment, '/// Doc');
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword, isNull);
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.propertyKeyword, isNotNull);
+    expect((method.returnType as TypeName).name.name, 'T');
+  }
+
+  void test_parseSetter_static() {
+    createParser('/// Doc\nstatic T set a(var x) {}');
+    MethodDeclaration method = parser.parseClassMember('C');
+    expect(method, isNotNull);
+    assertNoErrors();
+    expect(method.body, isNotNull);
+    expectCommentText(method.documentationComment, '/// Doc');
+    expect(method.externalKeyword, isNull);
+    expect(method.modifierKeyword.lexeme, 'static');
+    expect(method.name, isNotNull);
+    expect(method.operatorKeyword, isNull);
+    expect(method.typeParameters, isNull);
+    expect(method.parameters, isNotNull);
+    expect(method.propertyKeyword, isNotNull);
+    expect((method.returnType as TypeName).name.name, 'T');
+  }
+
+  void test_simpleFormalParameter_withDocComment() {
+    createParser('''
+int f(
+    /// Doc
+    int x) {}
+''');
+    var function = parseFullCompilationUnitMember() as FunctionDeclaration;
+    var parameter = function.functionExpression.parameters.parameters[0]
+        as NormalFormalParameter;
+    expectCommentText(parameter.documentationComment, '/// Doc');
+  }
+
+  /// Assert that the given [name] is in declaration context.
+  void _assertIsDeclarationName(SimpleIdentifier name, [bool expected = true]) {
+    expect(name.inDeclarationContext(), expected);
+  }
+
+  void _parseClassMember_method_native() {
+    createParser('m() native "str";');
+    var method = parser.parseClassMember('C') as MethodDeclaration;
+    var body = method.body as NativeFunctionBody;
+    expect(body.nativeKeyword, isNotNull);
+    expect(body.stringLiteral, isNotNull);
+    expect(body.stringLiteral?.stringValue, "str");
+    expect(body.semicolon, isNotNull);
+  }
+
+  void _parseClassMember_method_native_missing_literal() {
+    createParser('m() native;');
+    var method = parser.parseClassMember('C') as MethodDeclaration;
+    var body = method.body as NativeFunctionBody;
+    expect(body.nativeKeyword, isNotNull);
+    expect(body.stringLiteral, isNull);
+    expect(body.semicolon, isNotNull);
+  }
+
+  void _parseClassMember_method_native_with_body() {
+    createParser('m() native "str" {}');
+    parser.parseClassMember('C') as MethodDeclaration;
+  }
+}
diff --git a/pkg/analyzer/test/generated/collection_literal_parser_test.dart b/pkg/analyzer/test/generated/collection_literal_parser_test.dart
new file mode 100644
index 0000000..76e1dc8
--- /dev/null
+++ b/pkg/analyzer/test/generated/collection_literal_parser_test.dart
@@ -0,0 +1,649 @@
+// Copyright (c) 2020, 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.
+
+import 'package:analyzer/dart/analysis/features.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/error/error.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'parser_test_base.dart';
+import 'test_support.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(CollectionLiteralParserTest);
+  });
+}
+
+@reflectiveTest
+class CollectionLiteralParserTest extends FastaParserTestCase {
+  Expression parseCollectionLiteral(String source,
+      {List<ErrorCode> codes,
+      List<ExpectedError> errors,
+      int expectedEndOffset,
+      bool inAsync = false}) {
+    return parseExpression(source,
+        codes: codes,
+        errors: errors,
+        expectedEndOffset: expectedEndOffset,
+        inAsync: inAsync,
+        featureSet: FeatureSet.forTesting(
+            sdkVersion: '2.0.0',
+            additionalFeatures: [
+              Feature.spread_collections,
+              Feature.control_flow_collections
+            ]));
+  }
+
+  void test_listLiteral_for() {
+    var list = parseCollectionLiteral(
+      '[1, await for (var x in list) 2]',
+      inAsync: true,
+    ) as ListLiteral;
+    expect(list.elements, hasLength(2));
+    var first = list.elements[0] as IntegerLiteral;
+    expect(first.value, 1);
+
+    var second = list.elements[1] as ForElement;
+    expect(second.awaitKeyword, isNotNull);
+    expect(second.forKeyword.isKeyword, isTrue);
+    expect(second.leftParenthesis.lexeme, '(');
+    expect(second.rightParenthesis.lexeme, ')');
+    var forLoopParts = second.forLoopParts as ForEachPartsWithDeclaration;
+    DeclaredIdentifier forLoopVar = forLoopParts.loopVariable;
+    expect(forLoopVar.identifier.name, 'x');
+    expect(forLoopParts.inKeyword, isNotNull);
+    var iterable = forLoopParts.iterable as SimpleIdentifier;
+    expect(iterable.name, 'list');
+  }
+
+  void test_listLiteral_forIf() {
+    var list = parseCollectionLiteral(
+      '[1, await for (var x in list) if (c) 2]',
+      inAsync: true,
+    ) as ListLiteral;
+    expect(list.elements, hasLength(2));
+    var first = list.elements[0] as IntegerLiteral;
+    expect(first.value, 1);
+
+    var second = list.elements[1] as ForElement;
+    expect(second.awaitKeyword, isNotNull);
+    expect(second.forKeyword.isKeyword, isTrue);
+    expect(second.leftParenthesis.lexeme, '(');
+    expect(second.rightParenthesis.lexeme, ')');
+    var forLoopParts = second.forLoopParts as ForEachPartsWithDeclaration;
+    DeclaredIdentifier forLoopVar = forLoopParts.loopVariable;
+    expect(forLoopVar.identifier.name, 'x');
+    expect(forLoopParts.inKeyword, isNotNull);
+    var iterable = forLoopParts.iterable as SimpleIdentifier;
+    expect(iterable.name, 'list');
+
+    var body = second.body as IfElement;
+    var condition = body.condition as SimpleIdentifier;
+    expect(condition.name, 'c');
+    var thenElement = body.thenElement as IntegerLiteral;
+    expect(thenElement.value, 2);
+  }
+
+  void test_listLiteral_forSpread() {
+    var list =
+        parseCollectionLiteral('[1, for (int x = 0; x < 10; ++x) ...[2]]')
+            as ListLiteral;
+    expect(list.elements, hasLength(2));
+    var first = list.elements[0] as IntegerLiteral;
+    expect(first.value, 1);
+
+    var second = list.elements[1] as ForElement;
+    expect(second.awaitKeyword, isNull);
+    expect(second.forKeyword.isKeyword, isTrue);
+    expect(second.leftParenthesis.lexeme, '(');
+    expect(second.rightParenthesis.lexeme, ')');
+    var forLoopParts = second.forLoopParts as ForPartsWithDeclarations;
+    VariableDeclaration forLoopVar = forLoopParts.variables.variables[0];
+    expect(forLoopVar.name.name, 'x');
+    var condition = forLoopParts.condition as BinaryExpression;
+    var rightOperand = condition.rightOperand as IntegerLiteral;
+    expect(rightOperand.value, 10);
+    var updater = forLoopParts.updaters[0] as PrefixExpression;
+    var updaterOperand = updater.operand as SimpleIdentifier;
+    expect(updaterOperand.name, 'x');
+  }
+
+  void test_listLiteral_if() {
+    var list = parseCollectionLiteral('[1, if (true) 2]') as ListLiteral;
+    expect(list.elements, hasLength(2));
+    var first = list.elements[0] as IntegerLiteral;
+    expect(first.value, 1);
+
+    var second = list.elements[1] as IfElement;
+    var condition = second.condition as BooleanLiteral;
+    expect(condition.value, isTrue);
+    var thenElement = second.thenElement as IntegerLiteral;
+    expect(thenElement.value, 2);
+    expect(second.elseElement, isNull);
+  }
+
+  void test_listLiteral_ifElse() {
+    var list = parseCollectionLiteral('[1, if (true) 2 else 5]') as ListLiteral;
+    expect(list.elements, hasLength(2));
+    var first = list.elements[0] as IntegerLiteral;
+    expect(first.value, 1);
+
+    var second = list.elements[1] as IfElement;
+    var condition = second.condition as BooleanLiteral;
+    expect(condition.value, isTrue);
+    var thenElement = second.thenElement as IntegerLiteral;
+    expect(thenElement.value, 2);
+    var elseElement = second.elseElement as IntegerLiteral;
+    expect(elseElement.value, 5);
+  }
+
+  void test_listLiteral_ifElseFor() {
+    var list = parseCollectionLiteral('[1, if (true) 2 else for (a in b) 5]')
+        as ListLiteral;
+    expect(list.elements, hasLength(2));
+    var first = list.elements[0] as IntegerLiteral;
+    expect(first.value, 1);
+
+    var second = list.elements[1] as IfElement;
+    var condition = second.condition as BooleanLiteral;
+    expect(condition.value, isTrue);
+    var thenElement = second.thenElement as IntegerLiteral;
+    expect(thenElement.value, 2);
+
+    var elseElement = second.elseElement as ForElement;
+    var forLoopParts = elseElement.forLoopParts as ForEachPartsWithIdentifier;
+    expect(forLoopParts.identifier.name, 'a');
+
+    var forValue = elseElement.body as IntegerLiteral;
+    expect(forValue.value, 5);
+  }
+
+  void test_listLiteral_ifElseSpread() {
+    var list = parseCollectionLiteral('[1, if (true) ...[2] else ...?[5]]')
+        as ListLiteral;
+    expect(list.elements, hasLength(2));
+    var first = list.elements[0] as IntegerLiteral;
+    expect(first.value, 1);
+
+    var second = list.elements[1] as IfElement;
+    var condition = second.condition as BooleanLiteral;
+    expect(condition.value, isTrue);
+    var thenElement = second.thenElement as SpreadElement;
+    expect(thenElement.spreadOperator.lexeme, '...');
+    var elseElement = second.elseElement as SpreadElement;
+    expect(elseElement.spreadOperator.lexeme, '...?');
+  }
+
+  void test_listLiteral_ifFor() {
+    var list =
+        parseCollectionLiteral('[1, if (true) for (a in b) 2]') as ListLiteral;
+    expect(list.elements, hasLength(2));
+    var first = list.elements[0] as IntegerLiteral;
+    expect(first.value, 1);
+
+    var second = list.elements[1] as IfElement;
+    var condition = second.condition as BooleanLiteral;
+    expect(condition.value, isTrue);
+
+    var thenElement = second.thenElement as ForElement;
+    var forLoopParts = thenElement.forLoopParts as ForEachPartsWithIdentifier;
+    expect(forLoopParts.identifier.name, 'a');
+
+    var forValue = thenElement.body as IntegerLiteral;
+    expect(forValue.value, 2);
+    expect(second.elseElement, isNull);
+  }
+
+  void test_listLiteral_ifSpread() {
+    var list = parseCollectionLiteral('[1, if (true) ...[2]]') as ListLiteral;
+    expect(list.elements, hasLength(2));
+    var first = list.elements[0] as IntegerLiteral;
+    expect(first.value, 1);
+
+    var second = list.elements[1] as IfElement;
+    var condition = second.condition as BooleanLiteral;
+    expect(condition.value, isTrue);
+    var thenElement = second.thenElement as SpreadElement;
+    expect(thenElement.spreadOperator.lexeme, '...');
+    expect(second.elseElement, isNull);
+  }
+
+  void test_listLiteral_spread() {
+    var list = parseCollectionLiteral('[1, ...[2]]') as ListLiteral;
+    expect(list.elements, hasLength(2));
+    var first = list.elements[0] as IntegerLiteral;
+    expect(first.value, 1);
+
+    var element = list.elements[1] as SpreadElement;
+    expect(element.spreadOperator.lexeme, '...');
+    var spreadExpression = element.expression as ListLiteral;
+    expect(spreadExpression.elements, hasLength(1));
+  }
+
+  void test_listLiteral_spreadQ() {
+    var list = parseCollectionLiteral('[1, ...?[2]]') as ListLiteral;
+    expect(list.elements, hasLength(2));
+    var first = list.elements[0] as IntegerLiteral;
+    expect(first.value, 1);
+
+    var element = list.elements[1] as SpreadElement;
+    expect(element.spreadOperator.lexeme, '...?');
+    var spreadExpression = element.expression as ListLiteral;
+    expect(spreadExpression.elements, hasLength(1));
+  }
+
+  void test_mapLiteral_for() {
+    var map = parseCollectionLiteral('{1:7, await for (y in list) 2:3}',
+        inAsync: true) as SetOrMapLiteral;
+    expect(map.elements, hasLength(2));
+    var first = map.elements[0] as MapLiteralEntry;
+    var firstValue = first.value as IntegerLiteral;
+    expect(firstValue.value, 7);
+
+    var second = map.elements[1] as ForElement;
+    expect(second.awaitKeyword, isNotNull);
+    expect(second.forKeyword.isKeyword, isTrue);
+    expect(second.leftParenthesis.lexeme, '(');
+    expect(second.rightParenthesis.lexeme, ')');
+    var forLoopParts = second.forLoopParts as ForEachPartsWithIdentifier;
+    SimpleIdentifier forLoopVar = forLoopParts.identifier;
+    expect(forLoopVar.name, 'y');
+    expect(forLoopParts.inKeyword, isNotNull);
+    var iterable = forLoopParts.iterable as SimpleIdentifier;
+    expect(iterable.name, 'list');
+  }
+
+  void test_mapLiteral_forIf() {
+    var map = parseCollectionLiteral('{1:7, await for (y in list) if (c) 2:3}',
+        inAsync: true) as SetOrMapLiteral;
+    expect(map.elements, hasLength(2));
+    var first = map.elements[0] as MapLiteralEntry;
+    var firstValue = first.value as IntegerLiteral;
+    expect(firstValue.value, 7);
+
+    var second = map.elements[1] as ForElement;
+    expect(second.awaitKeyword, isNotNull);
+    expect(second.forKeyword.isKeyword, isTrue);
+    expect(second.leftParenthesis.lexeme, '(');
+    expect(second.rightParenthesis.lexeme, ')');
+    var forLoopParts = second.forLoopParts as ForEachPartsWithIdentifier;
+    SimpleIdentifier forLoopVar = forLoopParts.identifier;
+    expect(forLoopVar.name, 'y');
+    expect(forLoopParts.inKeyword, isNotNull);
+    var iterable = forLoopParts.iterable as SimpleIdentifier;
+    expect(iterable.name, 'list');
+
+    var body = second.body as IfElement;
+    var condition = body.condition as SimpleIdentifier;
+    expect(condition.name, 'c');
+    var thenElement = body.thenElement as MapLiteralEntry;
+    var thenValue = thenElement.value as IntegerLiteral;
+    expect(thenValue.value, 3);
+  }
+
+  void test_mapLiteral_forSpread() {
+    var map = parseCollectionLiteral('{1:7, for (x = 0; x < 10; ++x) ...{2:3}}')
+        as SetOrMapLiteral;
+    expect(map.elements, hasLength(2));
+    var first = map.elements[0] as MapLiteralEntry;
+    var firstValue = first.value as IntegerLiteral;
+    expect(firstValue.value, 7);
+
+    var second = map.elements[1] as ForElement;
+    expect(second.awaitKeyword, isNull);
+    expect(second.forKeyword.isKeyword, isTrue);
+    expect(second.leftParenthesis.lexeme, '(');
+    expect(second.rightParenthesis.lexeme, ')');
+    var forLoopParts = second.forLoopParts as ForPartsWithExpression;
+    var forLoopInit = forLoopParts.initialization as AssignmentExpression;
+    var forLoopVar = forLoopInit.leftHandSide as SimpleIdentifier;
+    expect(forLoopVar.name, 'x');
+    var condition = forLoopParts.condition as BinaryExpression;
+    var rightOperand = condition.rightOperand as IntegerLiteral;
+    expect(rightOperand.value, 10);
+    var updater = forLoopParts.updaters[0] as PrefixExpression;
+    var updaterOperand = updater.operand as SimpleIdentifier;
+    expect(updaterOperand.name, 'x');
+  }
+
+  void test_mapLiteral_if() {
+    var map = parseCollectionLiteral('{1:1, if (true) 2:4}') as SetOrMapLiteral;
+    expect(map.elements, hasLength(2));
+    var first = map.elements[0] as MapLiteralEntry;
+    var firstValue = first.value as IntegerLiteral;
+    expect(firstValue.value, 1);
+
+    var second = map.elements[1] as IfElement;
+    var condition = second.condition as BooleanLiteral;
+    expect(condition.value, isTrue);
+    var thenElement = second.thenElement as MapLiteralEntry;
+    var thenElementValue = thenElement.value as IntegerLiteral;
+    expect(thenElementValue.value, 4);
+    expect(second.elseElement, isNull);
+  }
+
+  void test_mapLiteral_ifElse() {
+    var map = parseCollectionLiteral('{1:1, if (true) 2:4 else 5:6}')
+        as SetOrMapLiteral;
+    expect(map.elements, hasLength(2));
+    var first = map.elements[0] as MapLiteralEntry;
+    var firstValue = first.value as IntegerLiteral;
+    expect(firstValue.value, 1);
+
+    var second = map.elements[1] as IfElement;
+    var condition = second.condition as BooleanLiteral;
+    expect(condition.value, isTrue);
+    var thenElement = second.thenElement as MapLiteralEntry;
+    var thenElementValue = thenElement.value as IntegerLiteral;
+    expect(thenElementValue.value, 4);
+    var elseElement = second.elseElement as MapLiteralEntry;
+    var elseElementValue = elseElement.value as IntegerLiteral;
+    expect(elseElementValue.value, 6);
+  }
+
+  void test_mapLiteral_ifElseFor() {
+    var map =
+        parseCollectionLiteral('{1:1, if (true) 2:4 else for (c in d) 5:6}')
+            as SetOrMapLiteral;
+    expect(map.elements, hasLength(2));
+    var first = map.elements[0] as MapLiteralEntry;
+    var firstValue = first.value as IntegerLiteral;
+    expect(firstValue.value, 1);
+
+    var second = map.elements[1] as IfElement;
+    var condition = second.condition as BooleanLiteral;
+    expect(condition.value, isTrue);
+    var thenElement = second.thenElement as MapLiteralEntry;
+    var thenElementValue = thenElement.value as IntegerLiteral;
+    expect(thenElementValue.value, 4);
+
+    var elseElement = second.elseElement as ForElement;
+    var forLoopParts = elseElement.forLoopParts as ForEachPartsWithIdentifier;
+    expect(forLoopParts.identifier.name, 'c');
+
+    var body = elseElement.body as MapLiteralEntry;
+    var bodyValue = body.value as IntegerLiteral;
+    expect(bodyValue.value, 6);
+  }
+
+  void test_mapLiteral_ifElseSpread() {
+    var map = parseCollectionLiteral('{1:7, if (true) ...{2:4} else ...?{5:6}}')
+        as SetOrMapLiteral;
+    expect(map.elements, hasLength(2));
+    var first = map.elements[0] as MapLiteralEntry;
+    var firstValue = first.value as IntegerLiteral;
+    expect(firstValue.value, 7);
+
+    var second = map.elements[1] as IfElement;
+    var condition = second.condition as BooleanLiteral;
+    expect(condition.value, isTrue);
+    var thenElement = second.thenElement as SpreadElement;
+    expect(thenElement.spreadOperator.lexeme, '...');
+    var elseElement = second.elseElement as SpreadElement;
+    expect(elseElement.spreadOperator.lexeme, '...?');
+    var elseElementExpression = elseElement.expression as SetOrMapLiteral;
+    expect(elseElementExpression.elements, hasLength(1));
+    var entry = elseElementExpression.elements[0] as MapLiteralEntry;
+    var entryValue = entry.value as IntegerLiteral;
+    expect(entryValue.value, 6);
+  }
+
+  void test_mapLiteral_ifFor() {
+    var map = parseCollectionLiteral('{1:1, if (true) for (a in b) 2:4}')
+        as SetOrMapLiteral;
+    expect(map.elements, hasLength(2));
+    var first = map.elements[0] as MapLiteralEntry;
+    var firstValue = first.value as IntegerLiteral;
+    expect(firstValue.value, 1);
+
+    var second = map.elements[1] as IfElement;
+    var condition = second.condition as BooleanLiteral;
+    expect(condition.value, isTrue);
+
+    var thenElement = second.thenElement as ForElement;
+    var forLoopParts = thenElement.forLoopParts as ForEachPartsWithIdentifier;
+    expect(forLoopParts.identifier.name, 'a');
+
+    var body = thenElement.body as MapLiteralEntry;
+    var thenElementValue = body.value as IntegerLiteral;
+    expect(thenElementValue.value, 4);
+    expect(second.elseElement, isNull);
+  }
+
+  void test_mapLiteral_ifSpread() {
+    SetOrMapLiteral map = parseCollectionLiteral('{1:1, if (true) ...{2:4}}');
+    expect(map.elements, hasLength(2));
+    var first = map.elements[0] as MapLiteralEntry;
+    var firstValue = first.value as IntegerLiteral;
+    expect(firstValue.value, 1);
+
+    var second = map.elements[1] as IfElement;
+    var condition = second.condition as BooleanLiteral;
+    expect(condition.value, isTrue);
+    var thenElement = second.thenElement as SpreadElement;
+    expect(thenElement.spreadOperator.lexeme, '...');
+    expect(second.elseElement, isNull);
+  }
+
+  void test_mapLiteral_spread() {
+    var map = parseCollectionLiteral('{1: 2, ...{3: 4}}') as SetOrMapLiteral;
+    expect(map.constKeyword, isNull);
+    expect(map.typeArguments, isNull);
+    expect(map.elements, hasLength(2));
+
+    var element = map.elements[1] as SpreadElement;
+    expect(element.spreadOperator.lexeme, '...');
+    var spreadExpression = element.expression as SetOrMapLiteral;
+    expect(spreadExpression.elements, hasLength(1));
+  }
+
+  void test_mapLiteral_spread2_typed() {
+    var map = parseCollectionLiteral('<int, int>{1: 2, ...{3: 4}}')
+        as SetOrMapLiteral;
+    expect(map.constKeyword, isNull);
+    expect(map.typeArguments.arguments, hasLength(2));
+    expect(map.elements, hasLength(2));
+
+    var element = map.elements[1] as SpreadElement;
+    expect(element.spreadOperator.lexeme, '...');
+    var spreadExpression = element.expression as SetOrMapLiteral;
+    expect(spreadExpression.elements, hasLength(1));
+  }
+
+  void test_mapLiteral_spread_typed() {
+    var map =
+        parseCollectionLiteral('<int, int>{...{3: 4}}') as SetOrMapLiteral;
+    expect(map.constKeyword, isNull);
+    expect(map.typeArguments.arguments, hasLength(2));
+    expect(map.elements, hasLength(1));
+
+    var element = map.elements[0] as SpreadElement;
+    expect(element.spreadOperator.lexeme, '...');
+    var spreadExpression = element.expression as SetOrMapLiteral;
+    expect(spreadExpression.elements, hasLength(1));
+  }
+
+  void test_mapLiteral_spreadQ() {
+    var map = parseCollectionLiteral('{1: 2, ...?{3: 4}}') as SetOrMapLiteral;
+    expect(map.constKeyword, isNull);
+    expect(map.typeArguments, isNull);
+    expect(map.elements, hasLength(2));
+
+    var element = map.elements[1] as SpreadElement;
+    expect(element.spreadOperator.lexeme, '...?');
+    var spreadExpression = element.expression as SetOrMapLiteral;
+    expect(spreadExpression.elements, hasLength(1));
+  }
+
+  void test_mapLiteral_spreadQ2_typed() {
+    var map = parseCollectionLiteral('<int, int>{1: 2, ...?{3: 4}}')
+        as SetOrMapLiteral;
+    expect(map.constKeyword, isNull);
+    expect(map.typeArguments.arguments, hasLength(2));
+    expect(map.elements, hasLength(2));
+
+    var element = map.elements[1] as SpreadElement;
+    expect(element.spreadOperator.lexeme, '...?');
+    var spreadExpression = element.expression as SetOrMapLiteral;
+    expect(spreadExpression.elements, hasLength(1));
+  }
+
+  void test_mapLiteral_spreadQ_typed() {
+    var map =
+        parseCollectionLiteral('<int, int>{...?{3: 4}}') as SetOrMapLiteral;
+    expect(map.constKeyword, isNull);
+    expect(map.typeArguments.arguments, hasLength(2));
+    expect(map.elements, hasLength(1));
+
+    var element = map.elements[0] as SpreadElement;
+    expect(element.spreadOperator.lexeme, '...?');
+    var spreadExpression = element.expression as SetOrMapLiteral;
+    expect(spreadExpression.elements, hasLength(1));
+  }
+
+  void test_setLiteral_if() {
+    var setLiteral =
+        parseCollectionLiteral('{1, if (true) 2}') as SetOrMapLiteral;
+    expect(setLiteral.elements, hasLength(2));
+    var first = setLiteral.elements[0] as IntegerLiteral;
+    expect(first.value, 1);
+
+    var second = setLiteral.elements[1] as IfElement;
+    var condition = second.condition as BooleanLiteral;
+    expect(condition.value, isTrue);
+    var thenElement = second.thenElement as IntegerLiteral;
+    expect(thenElement.value, 2);
+    expect(second.elseElement, isNull);
+  }
+
+  void test_setLiteral_ifElse() {
+    var setLiteral =
+        parseCollectionLiteral('{1, if (true) 2 else 5}') as SetOrMapLiteral;
+    expect(setLiteral.elements, hasLength(2));
+    var first = setLiteral.elements[0] as IntegerLiteral;
+    expect(first.value, 1);
+
+    var second = setLiteral.elements[1] as IfElement;
+    var condition = second.condition as BooleanLiteral;
+    expect(condition.value, isTrue);
+    var thenElement = second.thenElement as IntegerLiteral;
+    expect(thenElement.value, 2);
+    var elseElement = second.elseElement as IntegerLiteral;
+    expect(elseElement.value, 5);
+  }
+
+  void test_setLiteral_ifElseSpread() {
+    var setLiteral =
+        parseCollectionLiteral('{1, if (true) ...{2} else ...?[5]}')
+            as SetOrMapLiteral;
+    expect(setLiteral.elements, hasLength(2));
+    var first = setLiteral.elements[0] as IntegerLiteral;
+    expect(first.value, 1);
+
+    var second = setLiteral.elements[1] as IfElement;
+    var condition = second.condition as BooleanLiteral;
+    expect(condition.value, isTrue);
+    var thenElement = second.thenElement as SpreadElement;
+    expect(thenElement.spreadOperator.lexeme, '...');
+    var theExpression = thenElement.expression as SetOrMapLiteral;
+    expect(theExpression.elements, hasLength(1));
+    var elseElement = second.elseElement as SpreadElement;
+    expect(elseElement.spreadOperator.lexeme, '...?');
+    var elseExpression = elseElement.expression as ListLiteral;
+    expect(elseExpression.elements, hasLength(1));
+  }
+
+  void test_setLiteral_ifSpread() {
+    var setLiteral =
+        parseCollectionLiteral('{1, if (true) ...[2]}') as SetOrMapLiteral;
+    expect(setLiteral.elements, hasLength(2));
+    var first = setLiteral.elements[0] as IntegerLiteral;
+    expect(first.value, 1);
+
+    var second = setLiteral.elements[1] as IfElement;
+    var condition = second.condition as BooleanLiteral;
+    expect(condition.value, isTrue);
+    var thenElement = second.thenElement as SpreadElement;
+    expect(thenElement.spreadOperator.lexeme, '...');
+    expect(second.elseElement, isNull);
+  }
+
+  void test_setLiteral_spread2() {
+    var set = parseCollectionLiteral('{3, ...[4]}') as SetOrMapLiteral;
+    expect(set.constKeyword, isNull);
+    expect(set.typeArguments, isNull);
+    expect(set.elements, hasLength(2));
+    var value = set.elements[0] as IntegerLiteral;
+    expect(value.value, 3);
+
+    var element = set.elements[1] as SpreadElement;
+    expect(element.spreadOperator.lexeme, '...');
+    var spreadExpression = element.expression as ListLiteral;
+    expect(spreadExpression.elements, hasLength(1));
+  }
+
+  void test_setLiteral_spread2Q() {
+    var set = parseCollectionLiteral('{3, ...?[4]}') as SetOrMapLiteral;
+    expect(set.constKeyword, isNull);
+    expect(set.typeArguments, isNull);
+    expect(set.elements, hasLength(2));
+    var value = set.elements[0] as IntegerLiteral;
+    expect(value.value, 3);
+
+    var element = set.elements[1] as SpreadElement;
+    expect(element.spreadOperator.lexeme, '...?');
+    var spreadExpression = element.expression as ListLiteral;
+    expect(spreadExpression.elements, hasLength(1));
+  }
+
+  void test_setLiteral_spread_typed() {
+    var set = parseCollectionLiteral('<int>{...[3]}') as SetOrMapLiteral;
+    expect(set.constKeyword, isNull);
+    expect(set.typeArguments, isNotNull);
+    expect(set.elements, hasLength(1));
+
+    var element = set.elements[0] as SpreadElement;
+    expect(element.spreadOperator.lexeme, '...');
+    var spreadExpression = element.expression as ListLiteral;
+    expect(spreadExpression.elements, hasLength(1));
+  }
+
+  void test_setLiteral_spreadQ_typed() {
+    var set = parseCollectionLiteral('<int>{...?[3]}') as SetOrMapLiteral;
+    expect(set.constKeyword, isNull);
+    expect(set.typeArguments, isNotNull);
+    expect(set.elements, hasLength(1));
+
+    var element = set.elements[0] as SpreadElement;
+    expect(element.spreadOperator.lexeme, '...?');
+    var spreadExpression = element.expression as ListLiteral;
+    expect(spreadExpression.elements, hasLength(1));
+  }
+
+  void test_setOrMapLiteral_spread() {
+    var map = parseCollectionLiteral('{...{3: 4}}') as SetOrMapLiteral;
+    expect(map.constKeyword, isNull);
+    expect(map.typeArguments, isNull);
+    expect(map.elements, hasLength(1));
+
+    var element = map.elements[0] as SpreadElement;
+    expect(element.spreadOperator.lexeme, '...');
+    var spreadExpression = element.expression as SetOrMapLiteral;
+    expect(spreadExpression.elements, hasLength(1));
+  }
+
+  void test_setOrMapLiteral_spreadQ() {
+    var map = parseCollectionLiteral('{...?{3: 4}}') as SetOrMapLiteral;
+    expect(map.constKeyword, isNull);
+    expect(map.typeArguments, isNull);
+    expect(map.elements, hasLength(1));
+
+    var element = map.elements[0] as SpreadElement;
+    expect(element.spreadOperator.lexeme, '...?');
+    var spreadExpression = element.expression as SetOrMapLiteral;
+    expect(spreadExpression.elements, hasLength(1));
+  }
+}
diff --git a/pkg/analyzer/test/generated/complex_parser_test.dart b/pkg/analyzer/test/generated/complex_parser_test.dart
new file mode 100644
index 0000000..67ae21b
--- /dev/null
+++ b/pkg/analyzer/test/generated/complex_parser_test.dart
@@ -0,0 +1,573 @@
+// Copyright (c) 2020, 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.
+
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/error/error.dart';
+import 'package:analyzer/src/dart/scanner/scanner.dart';
+import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../util/ast_type_matchers.dart';
+import 'parser_test_base.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(ComplexParserTest);
+  });
+}
+
+/// The class `ComplexParserTest` defines parser tests that test the parsing of
+/// more complex code fragments or the interactions between multiple parsing
+/// methods. For example, tests to ensure that the precedence of operations is
+/// being handled correctly should be defined in this class.
+///
+/// Simpler tests should be defined in the class [SimpleParserTest].
+@reflectiveTest
+class ComplexParserTest extends FastaParserTestCase {
+  void test_additiveExpression_normal() {
+    BinaryExpression expression = parseExpression("x + y - z");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_additiveExpression_noSpaces() {
+    BinaryExpression expression = parseExpression("i+1");
+    expect(expression.leftOperand, isSimpleIdentifier);
+    expect(expression.rightOperand, isIntegerLiteral);
+  }
+
+  void test_additiveExpression_precedence_multiplicative_left() {
+    BinaryExpression expression = parseExpression("x * y + z");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_additiveExpression_precedence_multiplicative_left_withSuper() {
+    BinaryExpression expression = parseExpression("super * y - z");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_additiveExpression_precedence_multiplicative_right() {
+    BinaryExpression expression = parseExpression("x + y * z");
+    expect(expression.rightOperand, isBinaryExpression);
+  }
+
+  void test_additiveExpression_super() {
+    BinaryExpression expression = parseExpression("super + y - z");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_assignableExpression_arguments_normal_chain() {
+    PropertyAccess propertyAccess1 = parseExpression("a(b)(c).d(e).f");
+    expect(propertyAccess1.propertyName.name, "f");
+    //
+    // a(b)(c).d(e)
+    //
+    MethodInvocation invocation2 = propertyAccess1.target;
+    expect(invocation2.methodName.name, "d");
+    expect(invocation2.typeArguments, isNull);
+    ArgumentList argumentList2 = invocation2.argumentList;
+    expect(argumentList2, isNotNull);
+    expect(argumentList2.arguments, hasLength(1));
+    //
+    // a(b)(c)
+    //
+    FunctionExpressionInvocation invocation3 = invocation2.target;
+    expect(invocation3.typeArguments, isNull);
+    ArgumentList argumentList3 = invocation3.argumentList;
+    expect(argumentList3, isNotNull);
+    expect(argumentList3.arguments, hasLength(1));
+    //
+    // a(b)
+    //
+    MethodInvocation invocation4 = invocation3.function;
+    expect(invocation4.methodName.name, "a");
+    expect(invocation4.typeArguments, isNull);
+    ArgumentList argumentList4 = invocation4.argumentList;
+    expect(argumentList4, isNotNull);
+    expect(argumentList4.arguments, hasLength(1));
+  }
+
+  void test_assignableExpression_arguments_normal_chain_typeArguments() {
+    _validate_assignableExpression_arguments_normal_chain_typeArguments(
+        "a<E>(b)<F>(c).d<G>(e).f");
+  }
+
+  void test_assignmentExpression_compound() {
+    AssignmentExpression expression = parseExpression("x = y = 0");
+    expect(expression.leftHandSide, isSimpleIdentifier);
+    expect(expression.rightHandSide, isAssignmentExpression);
+  }
+
+  void test_assignmentExpression_indexExpression() {
+    AssignmentExpression expression = parseExpression("x[1] = 0");
+    expect(expression.leftHandSide, isIndexExpression);
+    expect(expression.rightHandSide, isIntegerLiteral);
+  }
+
+  void test_assignmentExpression_prefixedIdentifier() {
+    AssignmentExpression expression = parseExpression("x.y = 0");
+    expect(expression.leftHandSide, isPrefixedIdentifier);
+    expect(expression.rightHandSide, isIntegerLiteral);
+  }
+
+  void test_assignmentExpression_propertyAccess() {
+    AssignmentExpression expression = parseExpression("super.y = 0");
+    expect(expression.leftHandSide, isPropertyAccess);
+    expect(expression.rightHandSide, isIntegerLiteral);
+  }
+
+  void test_binary_operator_written_out_expression() {
+    var expression = parseExpression('x xor y', errors: [
+      expectedError(ParserErrorCode.BINARY_OPERATOR_WRITTEN_OUT, 2, 3),
+    ]) as BinaryExpression;
+    var lhs = expression.leftOperand as SimpleIdentifier;
+    expect(lhs.name, 'x');
+    expect(expression.operator.lexeme, '^');
+    var rhs = expression.rightOperand as SimpleIdentifier;
+    expect(rhs.name, 'y');
+  }
+
+  void test_bitwiseAndExpression_normal() {
+    BinaryExpression expression = parseExpression("x & y & z");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_bitwiseAndExpression_precedence_equality_left() {
+    BinaryExpression expression = parseExpression("x == y && z");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_bitwiseAndExpression_precedence_equality_right() {
+    BinaryExpression expression = parseExpression("x && y == z");
+    expect(expression.rightOperand, isBinaryExpression);
+  }
+
+  void test_bitwiseAndExpression_super() {
+    BinaryExpression expression = parseExpression("super & y & z");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_bitwiseOrExpression_normal() {
+    BinaryExpression expression = parseExpression("x | y | z");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_bitwiseOrExpression_precedence_xor_left() {
+    BinaryExpression expression = parseExpression("x ^ y | z");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_bitwiseOrExpression_precedence_xor_right() {
+    BinaryExpression expression = parseExpression("x | y ^ z");
+    expect(expression.rightOperand, isBinaryExpression);
+  }
+
+  void test_bitwiseOrExpression_super() {
+    BinaryExpression expression = parseExpression("super | y | z");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_bitwiseXorExpression_normal() {
+    BinaryExpression expression = parseExpression("x ^ y ^ z");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_bitwiseXorExpression_precedence_and_left() {
+    BinaryExpression expression = parseExpression("x & y ^ z");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_bitwiseXorExpression_precedence_and_right() {
+    BinaryExpression expression = parseExpression("x ^ y & z");
+    expect(expression.rightOperand, isBinaryExpression);
+  }
+
+  void test_bitwiseXorExpression_super() {
+    BinaryExpression expression = parseExpression("super ^ y ^ z");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_cascade_withAssignment() {
+    CascadeExpression cascade =
+        parseExpression("new Map()..[3] = 4 ..[0] = 11");
+    Expression target = cascade.target;
+    for (Expression section in cascade.cascadeSections) {
+      expect(section, isAssignmentExpression);
+      Expression lhs = (section as AssignmentExpression).leftHandSide;
+      expect(lhs, isIndexExpression);
+      IndexExpression index = lhs as IndexExpression;
+      expect(index.isCascaded, isTrue);
+      expect(index.realTarget, same(target));
+    }
+  }
+
+  void test_conditionalExpression_precedence_ifNullExpression() {
+    ConditionalExpression expression = parseExpression('a ?? b ? y : z');
+    expect(expression.condition, isBinaryExpression);
+  }
+
+  void test_conditionalExpression_precedence_logicalOrExpression() {
+    ConditionalExpression expression = parseExpression("a | b ? y : z");
+    expect(expression.condition, isBinaryExpression);
+  }
+
+  void test_conditionalExpression_precedence_nullableType_as() {
+    ExpressionStatement statement = parseStatement('x as bool ? (x + y) : z;');
+    ConditionalExpression expression = statement.expression;
+    Expression condition = expression.condition;
+    expect(condition, isAsExpression);
+    Expression thenExpression = expression.thenExpression;
+    expect(thenExpression, isParenthesizedExpression);
+    Expression elseExpression = expression.elseExpression;
+    expect(elseExpression, isSimpleIdentifier);
+  }
+
+  void test_conditionalExpression_precedence_nullableType_as2() {
+    var statement =
+        parseStatement('x as bool? ? (x + y) : z;') as ExpressionStatement;
+    var expression = statement.expression as ConditionalExpression;
+    var asExpression = expression.condition as AsExpression;
+    var type = asExpression.type as TypeName;
+    expect(type.question.lexeme, '?');
+    Expression thenExpression = expression.thenExpression;
+    expect(thenExpression, isParenthesizedExpression);
+    Expression elseExpression = expression.elseExpression;
+    expect(elseExpression, isSimpleIdentifier);
+    assertNoErrors();
+  }
+
+  void test_conditionalExpression_precedence_nullableType_as3() {
+    var statement =
+        parseStatement('(x as bool?) ? (x + y) : z;') as ExpressionStatement;
+    var expression = statement.expression as ConditionalExpression;
+    var condition = expression.condition as ParenthesizedExpression;
+    var asExpression = condition.expression as AsExpression;
+    var type = asExpression.type as TypeName;
+    expect(type.question.lexeme, '?');
+    Expression thenExpression = expression.thenExpression;
+    expect(thenExpression, isParenthesizedExpression);
+    Expression elseExpression = expression.elseExpression;
+    expect(elseExpression, isSimpleIdentifier);
+    assertNoErrors();
+  }
+
+  void test_conditionalExpression_precedence_nullableType_is() {
+    ExpressionStatement statement =
+        parseStatement('x is String ? (x + y) : z;');
+    ConditionalExpression expression = statement.expression;
+    Expression condition = expression.condition;
+    expect(condition, isIsExpression);
+    Expression thenExpression = expression.thenExpression;
+    expect(thenExpression, isParenthesizedExpression);
+    Expression elseExpression = expression.elseExpression;
+    expect(elseExpression, isSimpleIdentifier);
+  }
+
+  void test_conditionalExpression_precedence_nullableType_is2() {
+    var statement =
+        parseStatement('x is String? ? (x + y) : z;') as ExpressionStatement;
+    var expression = statement.expression as ConditionalExpression;
+    var isExpression = expression.condition as IsExpression;
+    var type = isExpression.type as TypeName;
+    expect(type.question.lexeme, '?');
+    Expression thenExpression = expression.thenExpression;
+    expect(thenExpression, isParenthesizedExpression);
+    Expression elseExpression = expression.elseExpression;
+    expect(elseExpression, isSimpleIdentifier);
+    assertNoErrors();
+  }
+
+  void test_conditionalExpression_precedence_nullableType_is3() {
+    var statement =
+        parseStatement('(x is String?) ? (x + y) : z;') as ExpressionStatement;
+    var expression = statement.expression as ConditionalExpression;
+    var condition = expression.condition as ParenthesizedExpression;
+    var isExpression = condition.expression as IsExpression;
+    var type = isExpression.type as TypeName;
+    expect(type.question.lexeme, '?');
+    Expression thenExpression = expression.thenExpression;
+    expect(thenExpression, isParenthesizedExpression);
+    Expression elseExpression = expression.elseExpression;
+    expect(elseExpression, isSimpleIdentifier);
+    assertNoErrors();
+  }
+
+  void test_conditionalExpression_precedence_nullableTypeWithTypeArg1_is() {
+    ExpressionStatement statement =
+        parseStatement('x is String<S> ? (x + y) : z;');
+    ConditionalExpression expression = statement.expression;
+    Expression condition = expression.condition;
+    expect(condition, TypeMatcher<IsExpression>());
+    Expression thenExpression = expression.thenExpression;
+    expect(thenExpression, TypeMatcher<ParenthesizedExpression>());
+    Expression elseExpression = expression.elseExpression;
+    expect(elseExpression, TypeMatcher<SimpleIdentifier>());
+  }
+
+  void test_conditionalExpression_precedence_nullableTypeWithTypeArg1GFT_is() {
+    ExpressionStatement statement =
+        parseStatement('x is String<S> Function() ? (x + y) : z;');
+    ConditionalExpression expression = statement.expression;
+    Expression condition = expression.condition;
+    expect(condition, TypeMatcher<IsExpression>());
+    Expression thenExpression = expression.thenExpression;
+    expect(thenExpression, TypeMatcher<ParenthesizedExpression>());
+    Expression elseExpression = expression.elseExpression;
+    expect(elseExpression, TypeMatcher<SimpleIdentifier>());
+  }
+
+  void test_conditionalExpression_precedence_nullableTypeWithTypeArg2_is() {
+    ExpressionStatement statement =
+        parseStatement('x is String<S,T> ? (x + y) : z;');
+    ConditionalExpression expression = statement.expression;
+    Expression condition = expression.condition;
+    expect(condition, TypeMatcher<IsExpression>());
+    Expression thenExpression = expression.thenExpression;
+    expect(thenExpression, TypeMatcher<ParenthesizedExpression>());
+    Expression elseExpression = expression.elseExpression;
+    expect(elseExpression, TypeMatcher<SimpleIdentifier>());
+  }
+
+  void test_conditionalExpression_precedence_prefixedNullableType_is() {
+    ExpressionStatement statement = parseStatement('x is p.A ? (x + y) : z;');
+    ConditionalExpression expression = statement.expression;
+
+    Expression condition = expression.condition;
+    expect(condition, TypeMatcher<IsExpression>());
+    Expression thenExpression = expression.thenExpression;
+    expect(thenExpression, TypeMatcher<ParenthesizedExpression>());
+    Expression elseExpression = expression.elseExpression;
+    expect(elseExpression, TypeMatcher<SimpleIdentifier>());
+  }
+
+  void test_conditionalExpression_precedence_withAssignment() {
+    ExpressionStatement statement = parseStatement('b ? c = true : g();');
+    ConditionalExpression expression = statement.expression;
+    expect(expression.condition, TypeMatcher<SimpleIdentifier>());
+    expect(expression.thenExpression, TypeMatcher<AssignmentExpression>());
+  }
+
+  void test_conditionalExpression_precedence_withAssignment2() {
+    ExpressionStatement statement = parseStatement('b.x ? c = true : g();');
+    ConditionalExpression expression = statement.expression;
+    expect(expression.condition, TypeMatcher<PrefixedIdentifier>());
+    expect(expression.thenExpression, TypeMatcher<AssignmentExpression>());
+  }
+
+  void test_conditionalExpression_prefixedValue() {
+    ExpressionStatement statement = parseStatement('a.b ? y : z;');
+    ConditionalExpression expression = statement.expression;
+    expect(expression.condition, TypeMatcher<PrefixedIdentifier>());
+    expect(expression.thenExpression, TypeMatcher<SimpleIdentifier>());
+  }
+
+  void test_conditionalExpression_prefixedValue2() {
+    ExpressionStatement statement = parseStatement('a.b ? x.y : z;');
+    ConditionalExpression expression = statement.expression;
+    expect(expression.condition, TypeMatcher<PrefixedIdentifier>());
+    expect(expression.thenExpression, TypeMatcher<PrefixedIdentifier>());
+  }
+
+  void test_constructor_initializer_withParenthesizedExpression() {
+    CompilationUnit unit = parseCompilationUnit(r'''
+class C {
+  C() :
+    this.a = (b == null ? c : d) {
+  }
+}''');
+    NodeList<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(1));
+  }
+
+  void test_equalityExpression_normal() {
+    BinaryExpression expression = parseExpression("x == y != z",
+        codes: [ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND]);
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_equalityExpression_precedence_relational_left() {
+    BinaryExpression expression = parseExpression("x is y == z");
+    expect(expression.leftOperand, isIsExpression);
+  }
+
+  void test_equalityExpression_precedence_relational_right() {
+    BinaryExpression expression = parseExpression("x == y is z");
+    expect(expression.rightOperand, isIsExpression);
+  }
+
+  void test_equalityExpression_super() {
+    BinaryExpression expression = parseExpression("super == y != z",
+        codes: [ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND]);
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_ifNullExpression() {
+    BinaryExpression expression = parseExpression('x ?? y ?? z');
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_ifNullExpression_precedence_logicalOr_left() {
+    BinaryExpression expression = parseExpression('x || y ?? z');
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_ifNullExpression_precedence_logicalOr_right() {
+    BinaryExpression expression = parseExpression('x ?? y || z');
+    expect(expression.rightOperand, isBinaryExpression);
+  }
+
+  void test_logicalAndExpression() {
+    BinaryExpression expression = parseExpression("x && y && z");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_logicalAndExpression_precedence_bitwiseOr_left() {
+    BinaryExpression expression = parseExpression("x | y < z");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_logicalAndExpression_precedence_bitwiseOr_right() {
+    BinaryExpression expression = parseExpression("x < y | z");
+    expect(expression.rightOperand, isBinaryExpression);
+  }
+
+  void test_logicalAndExpressionStatement() {
+    // Assert that `<` and `>` are not interpreted as type arguments.
+    ExpressionStatement statement = parseStatement("C<T && T>U;");
+    BinaryExpression expression = statement.expression;
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_logicalOrExpression() {
+    BinaryExpression expression = parseExpression("x || y || z");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_logicalOrExpression_precedence_logicalAnd_left() {
+    BinaryExpression expression = parseExpression("x && y || z");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_logicalOrExpression_precedence_logicalAnd_right() {
+    BinaryExpression expression = parseExpression("x || y && z");
+    expect(expression.rightOperand, isBinaryExpression);
+  }
+
+  void test_methodInvocation1() {
+    // Assert that `<` and `>` are not interpreted as type arguments.
+    ExpressionStatement statement = parseStatement("f(a < b, c > 3);");
+    assertNoErrors();
+    MethodInvocation method = statement.expression;
+    expect(method.argumentList.arguments, hasLength(2));
+  }
+
+  void test_methodInvocation2() {
+    // Assert that `<` and `>` are not interpreted as type arguments.
+    ExpressionStatement statement = parseStatement("f(a < b, c >> 3);");
+    assertNoErrors();
+    MethodInvocation method = statement.expression;
+    expect(method.argumentList.arguments, hasLength(2));
+  }
+
+  void test_methodInvocation3() {
+    // Assert that `<` and `>` are not interpreted as type arguments.
+    ExpressionStatement statement = parseStatement("f(a < b, c < d >> 3);");
+    assertNoErrors();
+    MethodInvocation method = statement.expression;
+    expect(method.argumentList.arguments, hasLength(2));
+  }
+
+  void test_multipleLabels_statement() {
+    LabeledStatement statement = parseStatement("a: b: c: return x;");
+    expect(statement.labels, hasLength(3));
+    expect(statement.statement, isReturnStatement);
+  }
+
+  void test_multiplicativeExpression_normal() {
+    BinaryExpression expression = parseExpression("x * y / z");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_multiplicativeExpression_precedence_unary_left() {
+    BinaryExpression expression = parseExpression("-x * y");
+    expect(expression.leftOperand, isPrefixExpression);
+  }
+
+  void test_multiplicativeExpression_precedence_unary_right() {
+    BinaryExpression expression = parseExpression("x * -y");
+    expect(expression.rightOperand, isPrefixExpression);
+  }
+
+  void test_multiplicativeExpression_super() {
+    BinaryExpression expression = parseExpression("super * y / z");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_relationalExpression_precedence_shift_right() {
+    IsExpression expression = parseExpression("x << y is z");
+    expect(expression.expression, isBinaryExpression);
+  }
+
+  void test_shiftExpression_normal() {
+    BinaryExpression expression = parseExpression("x >> 4 << 3");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_shiftExpression_precedence_additive_left() {
+    BinaryExpression expression = parseExpression("x + y << z");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_shiftExpression_precedence_additive_right() {
+    BinaryExpression expression = parseExpression("x << y + z");
+    expect(expression.rightOperand, isBinaryExpression);
+  }
+
+  void test_shiftExpression_super() {
+    BinaryExpression expression = parseExpression("super >> 4 << 3");
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_topLevelFunction_nestedGenericFunction() {
+    parseCompilationUnit('''
+void f() {
+  void g<T>() {
+  }
+}
+''');
+  }
+
+  void _validate_assignableExpression_arguments_normal_chain_typeArguments(
+      String code,
+      [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
+    PropertyAccess propertyAccess1 = parseExpression(code, codes: errorCodes);
+    expect(propertyAccess1.propertyName.name, "f");
+    //
+    // a<E>(b)<F>(c).d<G>(e)
+    //
+    MethodInvocation invocation2 = propertyAccess1.target;
+    expect(invocation2.methodName.name, "d");
+    expect(invocation2.typeArguments, isNotNull);
+    ArgumentList argumentList2 = invocation2.argumentList;
+    expect(argumentList2, isNotNull);
+    expect(argumentList2.arguments, hasLength(1));
+    //
+    // a<E>(b)<F>(c)
+    //
+    FunctionExpressionInvocation invocation3 = invocation2.target;
+    expect(invocation3.typeArguments, isNotNull);
+    ArgumentList argumentList3 = invocation3.argumentList;
+    expect(argumentList3, isNotNull);
+    expect(argumentList3.arguments, hasLength(1));
+    //
+    // a(b)
+    //
+    MethodInvocation invocation4 = invocation3.function;
+    expect(invocation4.methodName.name, "a");
+    expect(invocation4.typeArguments, isNotNull);
+    ArgumentList argumentList4 = invocation4.argumentList;
+    expect(argumentList4, isNotNull);
+    expect(argumentList4.arguments, hasLength(1));
+  }
+}
diff --git a/pkg/analyzer/test/generated/error_parser_test.dart b/pkg/analyzer/test/generated/error_parser_test.dart
new file mode 100644
index 0000000..73f8f5f
--- /dev/null
+++ b/pkg/analyzer/test/generated/error_parser_test.dart
@@ -0,0 +1,3068 @@
+// Copyright (c) 2020, 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.
+
+import 'package:_fe_analyzer_shared/src/scanner/errors.dart';
+import 'package:_fe_analyzer_shared/src/scanner/scanner.dart' as fasta;
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/src/dart/scanner/scanner.dart';
+import 'package:analyzer/src/error/codes.dart';
+import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../util/ast_type_matchers.dart';
+import 'parser_test_base.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(ErrorParserTest);
+  });
+}
+
+/// This defines parser tests that test the parsing of code to ensure that
+/// errors are correctly reported, and in some cases, not reported.
+@reflectiveTest
+class ErrorParserTest extends FastaParserTestCase {
+  void test_abstractClassMember_constructor() {
+    createParser('abstract C.c();');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.ABSTRACT_CLASS_MEMBER, 0, 8)]);
+  }
+
+  void test_abstractClassMember_field() {
+    createParser('abstract C f;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    assertNoErrors();
+  }
+
+  void test_abstractClassMember_getter() {
+    createParser('abstract get m;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.ABSTRACT_CLASS_MEMBER, 0, 8)]);
+  }
+
+  void test_abstractClassMember_method() {
+    createParser('abstract m();');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.ABSTRACT_CLASS_MEMBER, 0, 8)]);
+  }
+
+  void test_abstractClassMember_setter() {
+    createParser('abstract set m(v);');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.ABSTRACT_CLASS_MEMBER, 0, 8)]);
+  }
+
+  void test_abstractEnum() {
+    parseCompilationUnit("abstract enum E {ONE}",
+        errors: [expectedError(ParserErrorCode.ABSTRACT_ENUM, 0, 8)]);
+  }
+
+  void test_abstractTopLevelFunction_function() {
+    parseCompilationUnit("abstract f(v) {}", errors: [
+      expectedError(ParserErrorCode.ABSTRACT_TOP_LEVEL_FUNCTION, 0, 8)
+    ]);
+  }
+
+  void test_abstractTopLevelFunction_getter() {
+    parseCompilationUnit("abstract get m {}", errors: [
+      expectedError(ParserErrorCode.ABSTRACT_TOP_LEVEL_FUNCTION, 0, 8)
+    ]);
+  }
+
+  void test_abstractTopLevelFunction_setter() {
+    parseCompilationUnit("abstract set m(v) {}", errors: [
+      expectedError(ParserErrorCode.ABSTRACT_TOP_LEVEL_FUNCTION, 0, 8)
+    ]);
+  }
+
+  void test_abstractTopLevelVariable() {
+    parseCompilationUnit("abstract C f;", errors: [
+      expectedError(ParserErrorCode.ABSTRACT_TOP_LEVEL_VARIABLE, 0, 8)
+    ]);
+  }
+
+  void test_abstractTypeDef() {
+    parseCompilationUnit("abstract typedef F();",
+        errors: [expectedError(ParserErrorCode.ABSTRACT_TYPEDEF, 0, 8)]);
+  }
+
+  void test_await_missing_async2_issue36048() {
+    parseCompilationUnit('''
+main() { // missing async
+  await foo.bar();
+}
+''', errors: [
+      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 28, 5)
+    ]);
+  }
+
+  void test_await_missing_async3_issue36048() {
+    parseCompilationUnit('''
+main() { // missing async
+  (await foo);
+}
+''', errors: [
+      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 29, 5)
+    ]);
+  }
+
+  void test_await_missing_async4_issue36048() {
+    parseCompilationUnit('''
+main() { // missing async
+  [await foo];
+}
+''', errors: [
+      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 29, 5)
+    ]);
+  }
+
+  void test_await_missing_async_issue36048() {
+    parseCompilationUnit('''
+main() { // missing async
+  await foo();
+}
+''', errors: [
+      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 28, 5)
+    ]);
+  }
+
+  void test_breakOutsideOfLoop_breakInDoStatement() {
+    DoStatement statement = parseStatement('do {break;} while (x);');
+    expectNotNullIfNoErrors(statement);
+    assertNoErrors();
+  }
+
+  void test_breakOutsideOfLoop_breakInForStatement() {
+    Statement statement = parseStatement('for (; x;) {break;}');
+    expectNotNullIfNoErrors(statement);
+    assertNoErrors();
+  }
+
+  void test_breakOutsideOfLoop_breakInIfStatement() {
+    IfStatement statement = parseStatement('if (x) {break;}');
+    expectNotNullIfNoErrors(statement);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.BREAK_OUTSIDE_OF_LOOP, 8, 5)]);
+  }
+
+  void test_breakOutsideOfLoop_breakInSwitchStatement() {
+    SwitchStatement statement = parseStatement('switch (x) {case 1: break;}');
+    expectNotNullIfNoErrors(statement);
+    assertNoErrors();
+  }
+
+  void test_breakOutsideOfLoop_breakInWhileStatement() {
+    WhileStatement statement = parseStatement('while (x) {break;}');
+    expectNotNullIfNoErrors(statement);
+    assertNoErrors();
+  }
+
+  void test_breakOutsideOfLoop_functionExpression_inALoop() {
+    parseStatement("for(; x;) {() {break;};}");
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.BREAK_OUTSIDE_OF_LOOP, 15, 5)]);
+  }
+
+  void test_breakOutsideOfLoop_functionExpression_withALoop() {
+    parseStatement("() {for (; x;) {break;}};");
+  }
+
+  void test_classInClass_abstract() {
+    parseCompilationUnit("class C { abstract class B {} }", errors: [
+      expectedError(ParserErrorCode.ABSTRACT_CLASS_MEMBER, 10, 8),
+      expectedError(ParserErrorCode.CLASS_IN_CLASS, 19, 5)
+    ]);
+  }
+
+  void test_classInClass_nonAbstract() {
+    parseCompilationUnit("class C { class B {} }",
+        errors: [expectedError(ParserErrorCode.CLASS_IN_CLASS, 10, 5)]);
+  }
+
+  void test_classTypeAlias_abstractAfterEq() {
+    // This syntax has been removed from the language in favor of
+    // "abstract class A = B with C;" (issue 18098).
+    createParser('class A = abstract B with C;', expectedEndOffset: 21);
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([
+      expectedError(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE, 10, 8),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 19, 1),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 19, 1)
+    ]);
+  }
+
+  void test_colonInPlaceOfIn() {
+    parseStatement("for (var x : list) {}");
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.COLON_IN_PLACE_OF_IN, 11, 1)]);
+  }
+
+  void test_constAndCovariant() {
+    createParser('covariant const C f = null;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.CONFLICTING_MODIFIERS, 10, 5)]);
+  }
+
+  void test_constAndFinal() {
+    createParser('const final int x = null;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.CONST_AND_FINAL, 6, 5)]);
+  }
+
+  void test_constAndVar() {
+    createParser('const var x = null;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.CONFLICTING_MODIFIERS, 6, 3)]);
+  }
+
+  void test_constClass() {
+    parseCompilationUnit("const class C {}",
+        errors: [expectedError(ParserErrorCode.CONST_CLASS, 0, 5)]);
+  }
+
+  void test_constConstructorWithBody() {
+    createParser('const C() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.CONST_CONSTRUCTOR_WITH_BODY, 10, 1)]);
+  }
+
+  void test_constEnum() {
+    parseCompilationUnit("const enum E {ONE}", errors: [
+      // Fasta interprets the `const` as a malformed top level const
+      // and `enum` as the start of an enum declaration.
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 4),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 6, 4),
+    ]);
+  }
+
+  void test_constFactory() {
+    createParser('const factory C() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([expectedError(ParserErrorCode.CONST_FACTORY, 0, 5)]);
+  }
+
+  void test_constMethod() {
+    createParser('const int m() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([expectedError(ParserErrorCode.CONST_METHOD, 0, 5)]);
+  }
+
+  void test_constMethod_noReturnType() {
+    createParser('const m() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([expectedError(ParserErrorCode.CONST_METHOD, 0, 5)]);
+  }
+
+  void test_constMethod_noReturnType2() {
+    createParser('const m();');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([expectedError(ParserErrorCode.CONST_METHOD, 0, 5)]);
+  }
+
+  void test_constructor_super_cascade_synthetic() {
+    // https://github.com/dart-lang/sdk/issues/37110
+    parseCompilationUnit('class B extends A { B(): super.. {} }', errors: [
+      expectedError(ParserErrorCode.INVALID_SUPER_IN_INITIALIZER, 25, 5),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 30, 2),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 33, 1),
+    ]);
+  }
+
+  void test_constructor_super_field() {
+    // https://github.com/dart-lang/sdk/issues/36262
+    // https://github.com/dart-lang/sdk/issues/31198
+    parseCompilationUnit('class B extends A { B(): super().foo {} }', errors: [
+      expectedError(ParserErrorCode.INVALID_SUPER_IN_INITIALIZER, 25, 5),
+    ]);
+  }
+
+  void test_constructor_super_method() {
+    // https://github.com/dart-lang/sdk/issues/36262
+    // https://github.com/dart-lang/sdk/issues/31198
+    parseCompilationUnit('class B extends A { B(): super().foo() {} }',
+        errors: [
+          expectedError(ParserErrorCode.INVALID_SUPER_IN_INITIALIZER, 25, 5),
+        ]);
+  }
+
+  void test_constructor_super_named_method() {
+    // https://github.com/dart-lang/sdk/issues/37600
+    parseCompilationUnit('class B extends A { B(): super.c().create() {} }',
+        errors: [
+          expectedError(ParserErrorCode.INVALID_SUPER_IN_INITIALIZER, 25, 5),
+        ]);
+  }
+
+  void test_constructor_super_named_method_method() {
+    // https://github.com/dart-lang/sdk/issues/37600
+    parseCompilationUnit('class B extends A { B(): super.c().create().x() {} }',
+        errors: [
+          expectedError(ParserErrorCode.INVALID_SUPER_IN_INITIALIZER, 25, 5),
+        ]);
+  }
+
+  void test_constructor_this_cascade_synthetic() {
+    // https://github.com/dart-lang/sdk/issues/37110
+    parseCompilationUnit('class B extends A { B(): this.. {} }', errors: [
+      expectedError(ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 25, 4),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 29, 2),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 32, 1),
+    ]);
+  }
+
+  void test_constructor_this_field() {
+    // https://github.com/dart-lang/sdk/issues/36262
+    // https://github.com/dart-lang/sdk/issues/31198
+    parseCompilationUnit('class B extends A { B(): this().foo; }', errors: [
+      expectedError(ParserErrorCode.INVALID_THIS_IN_INITIALIZER, 25, 4),
+    ]);
+  }
+
+  void test_constructor_this_method() {
+    // https://github.com/dart-lang/sdk/issues/36262
+    // https://github.com/dart-lang/sdk/issues/31198
+    parseCompilationUnit('class B extends A { B(): this().foo(); }', errors: [
+      expectedError(ParserErrorCode.INVALID_THIS_IN_INITIALIZER, 25, 4),
+    ]);
+  }
+
+  void test_constructor_this_named_method() {
+    // https://github.com/dart-lang/sdk/issues/37600
+    parseCompilationUnit('class B extends A { B(): super.c().create() {} }',
+        errors: [
+          expectedError(ParserErrorCode.INVALID_SUPER_IN_INITIALIZER, 25, 5),
+        ]);
+  }
+
+  void test_constructor_this_named_method_field() {
+    // https://github.com/dart-lang/sdk/issues/37600
+    parseCompilationUnit('class B extends A { B(): super.c().create().x {} }',
+        errors: [
+          expectedError(ParserErrorCode.INVALID_SUPER_IN_INITIALIZER, 25, 5),
+        ]);
+  }
+
+  void test_constructorPartial() {
+    createParser('class C { C< }');
+    parser.parseCompilationUnit2();
+    listener.assertErrors([
+      expectedError(ParserErrorCode.TYPE_PARAMETER_ON_CONSTRUCTOR, 11, 2),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 13, 1),
+      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 10, 1),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 13, 1),
+    ]);
+  }
+
+  void test_constructorPartial2() {
+    createParser('class C { C<@Foo }');
+    parser.parseCompilationUnit2();
+    listener.assertErrors([
+      expectedError(ParserErrorCode.TYPE_PARAMETER_ON_CONSTRUCTOR, 11, 6),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 17, 1),
+      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 10, 1),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 17, 1)
+    ]);
+  }
+
+  void test_constructorPartial3() {
+    createParser('class C { C<@Foo @Bar() }');
+    parser.parseCompilationUnit2();
+    listener.assertErrors([
+      expectedError(ParserErrorCode.TYPE_PARAMETER_ON_CONSTRUCTOR, 11, 13),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 24, 1),
+      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 10, 1),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 24, 1)
+    ]);
+  }
+
+  void test_constructorWithReturnType() {
+    createParser('C C() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.CONSTRUCTOR_WITH_RETURN_TYPE, 0, 1),
+    ]);
+  }
+
+  void test_constructorWithReturnType_var() {
+    createParser('var C() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.VAR_RETURN_TYPE, 0, 3)]);
+  }
+
+  void test_constTypedef() {
+    parseCompilationUnit("const typedef F();", errors: [
+      // Fasta interprets the `const` as a malformed top level const
+      // and `typedef` as the start of an typedef declaration.
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 7),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 6, 7),
+    ]);
+  }
+
+  void test_continueOutsideOfLoop_continueInDoStatement() {
+    DoStatement statement = parseStatement('do {continue;} while (x);');
+    expectNotNullIfNoErrors(statement);
+    assertNoErrors();
+  }
+
+  void test_continueOutsideOfLoop_continueInForStatement() {
+    Statement statement = parseStatement('for (; x;) {continue;}');
+    expectNotNullIfNoErrors(statement);
+    assertNoErrors();
+  }
+
+  void test_continueOutsideOfLoop_continueInIfStatement() {
+    IfStatement statement = parseStatement('if (x) {continue;}');
+    expectNotNullIfNoErrors(statement);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.CONTINUE_OUTSIDE_OF_LOOP, 8, 8)]);
+  }
+
+  void test_continueOutsideOfLoop_continueInSwitchStatement() {
+    SwitchStatement statement =
+        parseStatement('switch (x) {case 1: continue a;}');
+    expectNotNullIfNoErrors(statement);
+    assertNoErrors();
+  }
+
+  void test_continueOutsideOfLoop_continueInWhileStatement() {
+    WhileStatement statement = parseStatement('while (x) {continue;}');
+    expectNotNullIfNoErrors(statement);
+    assertNoErrors();
+  }
+
+  void test_continueOutsideOfLoop_functionExpression_inALoop() {
+    parseStatement("for(; x;) {() {continue;};}");
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.CONTINUE_OUTSIDE_OF_LOOP, 15, 8)]);
+  }
+
+  void test_continueOutsideOfLoop_functionExpression_withALoop() {
+    parseStatement("() {for (; x;) {continue;}};");
+  }
+
+  void test_continueWithoutLabelInCase_error() {
+    SwitchStatement statement =
+        parseStatement('switch (x) {case 1: continue;}');
+    expectNotNullIfNoErrors(statement);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.CONTINUE_WITHOUT_LABEL_IN_CASE, 20, 8)]);
+  }
+
+  void test_continueWithoutLabelInCase_noError() {
+    SwitchStatement statement =
+        parseStatement('switch (x) {case 1: continue a;}');
+    expectNotNullIfNoErrors(statement);
+    assertNoErrors();
+  }
+
+  void test_continueWithoutLabelInCase_noError_switchInLoop() {
+    WhileStatement statement =
+        parseStatement('while (a) { switch (b) {default: continue;}}');
+    expectNotNullIfNoErrors(statement);
+    assertNoErrors();
+  }
+
+  void test_covariantAfterVar() {
+    createParser('var covariant f;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 4, 9)]);
+  }
+
+  void test_covariantAndFinal() {
+    createParser('covariant final f = null;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrorsWithCodes([ParserErrorCode.FINAL_AND_COVARIANT]);
+  }
+
+  void test_covariantAndStatic() {
+    createParser('covariant static A f;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.COVARIANT_AND_STATIC, 10, 6)]);
+  }
+
+  void test_covariantAndType_local() {
+    // This is currently reporting EXPECTED_TOKEN for a missing semicolon, but
+    // this would be a better error message.
+    parseStatement("covariant int x;");
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.EXTRANEOUS_MODIFIER, 0, 9)]);
+  }
+
+  void test_covariantConstructor() {
+    createParser('class C { covariant C(); }');
+    ClassDeclaration member = parseFullCompilationUnitMember();
+    expectNotNullIfNoErrors(member);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.COVARIANT_MEMBER, 10, 9)]);
+  }
+
+  void test_covariantMember_getter_noReturnType() {
+    createParser('static covariant get x => 0;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.COVARIANT_AND_STATIC, 7, 9)]);
+  }
+
+  void test_covariantMember_getter_returnType() {
+    createParser('static covariant int get x => 0;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.COVARIANT_AND_STATIC, 7, 9)]);
+  }
+
+  void test_covariantMember_method() {
+    createParser('covariant int m() => 0;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.COVARIANT_MEMBER, 0, 9)]);
+  }
+
+  void test_covariantTopLevelDeclaration_class() {
+    createParser('covariant class C {}');
+    ClassDeclaration member = parseFullCompilationUnitMember();
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.COVARIANT_TOP_LEVEL_DECLARATION, 0, 9)]);
+  }
+
+  void test_covariantTopLevelDeclaration_enum() {
+    createParser('covariant enum E { v }');
+    EnumDeclaration member = parseFullCompilationUnitMember();
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.COVARIANT_TOP_LEVEL_DECLARATION, 0, 9)]);
+  }
+
+  void test_covariantTopLevelDeclaration_typedef() {
+    parseCompilationUnit("covariant typedef F();", errors: [
+      expectedError(ParserErrorCode.COVARIANT_TOP_LEVEL_DECLARATION, 0, 9)
+    ]);
+  }
+
+  void test_defaultValueInFunctionType_named_colon() {
+    createParser('({int x : 0})');
+    FormalParameter parameter =
+        parser.parseFormalParameterList(inFunctionType: true).parameters[0];
+    expectNotNullIfNoErrors(parameter);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE, 8, 1)]);
+  }
+
+  void test_defaultValueInFunctionType_named_equal() {
+    createParser('({int x = 0})');
+    FormalParameter parameter =
+        parser.parseFormalParameterList(inFunctionType: true).parameters[0];
+    expectNotNullIfNoErrors(parameter);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE, 8, 1)]);
+  }
+
+  void test_defaultValueInFunctionType_positional() {
+    createParser('([int x = 0])');
+    FormalParameter parameter =
+        parser.parseFormalParameterList(inFunctionType: true).parameters[0];
+    expectNotNullIfNoErrors(parameter);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE, 8, 1)]);
+  }
+
+  void test_directiveAfterDeclaration_classBeforeDirective() {
+    // TODO(brianwilkerson) Remove codes when highlighting is fixed.
+    CompilationUnit unit = parseCompilationUnit("class Foo{} library l;",
+        codes: [
+          ParserErrorCode.LIBRARY_DIRECTIVE_NOT_FIRST
+        ],
+        errors: [
+          expectedError(ParserErrorCode.LIBRARY_DIRECTIVE_NOT_FIRST, 12, 10)
+        ]);
+    expect(unit, isNotNull);
+  }
+
+  void test_directiveAfterDeclaration_classBetweenDirectives() {
+    // TODO(brianwilkerson) Remove codes when highlighting is fixed.
+    CompilationUnit unit =
+        parseCompilationUnit("library l;\nclass Foo{}\npart 'a.dart';", codes: [
+      ParserErrorCode.DIRECTIVE_AFTER_DECLARATION
+    ], errors: [
+      expectedError(ParserErrorCode.DIRECTIVE_AFTER_DECLARATION, 23, 14)
+    ]);
+    expect(unit, isNotNull);
+  }
+
+  void test_duplicatedModifier_const() {
+    createParser('const const m = null;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.DUPLICATED_MODIFIER, 6, 5)]);
+  }
+
+  void test_duplicatedModifier_external() {
+    createParser('external external f();');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.DUPLICATED_MODIFIER, 9, 8)]);
+  }
+
+  void test_duplicatedModifier_factory() {
+    createParser('factory factory C() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.DUPLICATED_MODIFIER, 8, 7)]);
+  }
+
+  void test_duplicatedModifier_final() {
+    createParser('final final m = null;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.DUPLICATED_MODIFIER, 6, 5)]);
+  }
+
+  void test_duplicatedModifier_static() {
+    createParser('static static var m;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.DUPLICATED_MODIFIER, 7, 6)]);
+  }
+
+  void test_duplicatedModifier_var() {
+    createParser('var var m;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.DUPLICATED_MODIFIER, 4, 3)]);
+  }
+
+  void test_duplicateLabelInSwitchStatement() {
+    SwitchStatement statement =
+        parseStatement('switch (e) {l1: case 0: break; l1: case 1: break;}');
+    expectNotNullIfNoErrors(statement);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.DUPLICATE_LABEL_IN_SWITCH_STATEMENT, 31, 2)
+    ]);
+  }
+
+  void test_emptyEnumBody() {
+    createParser('enum E {}');
+    EnumDeclaration declaration = parseFullCompilationUnitMember();
+    expectNotNullIfNoErrors(declaration);
+    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
+    listener.assertErrorsWithCodes([ParserErrorCode.EMPTY_ENUM_BODY]);
+//    listener
+//        .assertErrors([expectedError(ParserErrorCode.EMPTY_ENUM_BODY, 7, 2),]);
+  }
+
+  void test_enumInClass() {
+    parseCompilationUnit(r'''
+class Foo {
+  enum Bar {
+    Bar1, Bar2, Bar3
+  }
+}
+''', errors: [expectedError(ParserErrorCode.ENUM_IN_CLASS, 14, 4)]);
+  }
+
+  void test_equalityCannotBeEqualityOperand_eq_eq() {
+    parseExpression("1 == 2 == 3", errors: [
+      expectedError(ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND, 7, 2)
+    ]);
+  }
+
+  void test_equalityCannotBeEqualityOperand_eq_neq() {
+    parseExpression("1 == 2 != 3", errors: [
+      expectedError(ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND, 7, 2)
+    ]);
+  }
+
+  void test_equalityCannotBeEqualityOperand_neq_eq() {
+    parseExpression("1 != 2 == 3", errors: [
+      expectedError(ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND, 7, 2)
+    ]);
+  }
+
+  void test_expectedBody_class() {
+    parseCompilationUnit("class A class B {}",
+        errors: [expectedError(ParserErrorCode.EXPECTED_BODY, 6, 1)]);
+  }
+
+  void test_expectedCaseOrDefault() {
+    SwitchStatement statement = parseStatement('switch (e) {break;}');
+    expectNotNullIfNoErrors(statement);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 12, 5)]);
+  }
+
+  void test_expectedClassMember_inClass_afterType() {
+    parseCompilationUnit('class C{ heart 2 heart }', errors: [
+      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 9, 5),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 9, 5),
+      expectedError(ParserErrorCode.EXPECTED_CLASS_MEMBER, 15, 1),
+      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 17, 5),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 17, 5)
+    ]);
+  }
+
+  void test_expectedClassMember_inClass_beforeType() {
+    parseCompilationUnit('class C { 4 score }', errors: [
+      expectedError(ParserErrorCode.EXPECTED_CLASS_MEMBER, 10, 1),
+      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 12, 5),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 12, 5)
+    ]);
+  }
+
+  void test_expectedExecutable_afterAnnotation_atEOF() {
+    // TODO(brianwilkerson) Remove codes when highlighting is fixed.
+    parseCompilationUnit('@A',
+        codes: [ParserErrorCode.EXPECTED_EXECUTABLE],
+        errors: [expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 1, 1)]);
+  }
+
+  void test_expectedExecutable_inClass_afterVoid() {
+    parseCompilationUnit('class C { void 2 void }', errors: [
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 15, 1),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 17, 4),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 22, 1),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 22, 1)
+    ]);
+  }
+
+  void test_expectedExecutable_topLevel_afterType() {
+    CompilationUnit unit = parseCompilationUnit('heart 2 heart', errors: [
+      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 0, 5),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 0, 5),
+      expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 6, 1),
+      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 8, 5),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 8, 5),
+    ]);
+    expect(unit, isNotNull);
+  }
+
+  void test_expectedExecutable_topLevel_afterVoid() {
+    CompilationUnit unit = parseCompilationUnit('void 2 void', errors: [
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 5, 1),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 5, 1),
+      expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 5, 1),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 11, 0),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 11, 0),
+    ]);
+    expect(unit, isNotNull);
+  }
+
+  void test_expectedExecutable_topLevel_beforeType() {
+    parseCompilationUnit('4 score', errors: [
+      expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 0, 1),
+      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 2, 5),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 2, 5),
+    ]);
+  }
+
+  void test_expectedExecutable_topLevel_eof() {
+    parseCompilationUnit('x', errors: [
+      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 0, 1),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 0, 1)
+    ]);
+  }
+
+  void test_expectedInterpolationIdentifier() {
+    StringLiteral literal = parseExpression("'\$x\$'",
+        errors: [expectedError(ScannerErrorCode.MISSING_IDENTIFIER, 4, 1)]);
+    expectNotNullIfNoErrors(literal);
+  }
+
+  void test_expectedInterpolationIdentifier_emptyString() {
+    // The scanner inserts an empty string token between the two $'s; we need to
+    // make sure that the MISSING_IDENTIFIER error that is generated has a
+    // nonzero width so that it will show up in the editor UI.
+    StringLiteral literal = parseExpression("'\$\$foo'",
+        errors: [expectedError(ScannerErrorCode.MISSING_IDENTIFIER, 2, 1)]);
+    expectNotNullIfNoErrors(literal);
+  }
+
+  void test_expectedToken_commaMissingInArgumentList() {
+    createParser('(x, y z)');
+    ArgumentList list = parser.parseArgumentList();
+    expectNotNullIfNoErrors(list);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 6, 1)]);
+  }
+
+  void test_expectedToken_parseStatement_afterVoid() {
+    parseStatement("void}", expectedEndOffset: 4);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 4, 1),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 4, 1)
+    ]);
+  }
+
+  void test_expectedToken_semicolonMissingAfterExport() {
+    // TODO(brianwilkerson) Remove codes when highlighting is fixed.
+    CompilationUnit unit = parseCompilationUnit("export '' class A {}",
+        codes: [ParserErrorCode.EXPECTED_TOKEN],
+        errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 2)]);
+    ExportDirective directive = unit.directives[0] as ExportDirective;
+    expect(directive.uri, isNotNull);
+    expect(directive.uri.stringValue, '');
+    expect(directive.uri.beginToken.isSynthetic, false);
+    expect(directive.uri.isSynthetic, false);
+    Token semicolon = directive.semicolon;
+    expect(semicolon, isNotNull);
+    expect(semicolon.isSynthetic, isTrue);
+    ClassDeclaration clazz = unit.declarations[0] as ClassDeclaration;
+    expect(clazz.name.name, 'A');
+  }
+
+  void test_expectedToken_semicolonMissingAfterExpression() {
+    parseStatement("x");
+    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
+    listener.assertErrorsWithCodes([ParserErrorCode.EXPECTED_TOKEN]);
+//    listener
+//        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 0, 1)]);
+  }
+
+  void test_expectedToken_semicolonMissingAfterImport() {
+    // TODO(brianwilkerson) Remove codes when highlighting is fixed.
+    CompilationUnit unit = parseCompilationUnit("import '' class A {}",
+        codes: [ParserErrorCode.EXPECTED_TOKEN],
+        errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 2)]);
+    ImportDirective directive = unit.directives[0] as ImportDirective;
+    Token semicolon = directive.semicolon;
+    expect(semicolon, isNotNull);
+    expect(semicolon.isSynthetic, isTrue);
+  }
+
+  void test_expectedToken_uriAndSemicolonMissingAfterExport() {
+    CompilationUnit unit = parseCompilationUnit("export class A {}", errors: [
+      expectedError(ParserErrorCode.EXPECTED_STRING_LITERAL, 7, 5),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 5),
+    ]);
+    ExportDirective directive = unit.directives[0] as ExportDirective;
+    expect(directive.uri, isNotNull);
+    expect(directive.uri.stringValue, '');
+    expect(directive.uri.beginToken.isSynthetic, true);
+    expect(directive.uri.isSynthetic, true);
+    Token semicolon = directive.semicolon;
+    expect(semicolon, isNotNull);
+    expect(semicolon.isSynthetic, isTrue);
+    ClassDeclaration clazz = unit.declarations[0] as ClassDeclaration;
+    expect(clazz.name.name, 'A');
+  }
+
+  void test_expectedToken_whileMissingInDoStatement() {
+    parseStatement("do {} (x);");
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 6, 1)]);
+  }
+
+  void test_expectedTypeName_as() {
+    parseExpression("x as",
+        errors: [expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 4, 0)]);
+  }
+
+  void test_expectedTypeName_as_void() {
+    parseExpression("x as void)",
+        expectedEndOffset: 9,
+        errors: [expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 5, 4)]);
+  }
+
+  void test_expectedTypeName_is() {
+    parseExpression("x is",
+        errors: [expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 4, 0)]);
+  }
+
+  void test_expectedTypeName_is_void() {
+    parseExpression("x is void)",
+        expectedEndOffset: 9,
+        errors: [expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 5, 4)]);
+  }
+
+  void test_exportAsType() {
+    parseCompilationUnit('export<dynamic> foo;', errors: [
+      expectedError(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE, 0, 6)
+    ]);
+  }
+
+  void test_exportAsType_inClass() {
+    parseCompilationUnit('class C { export<dynamic> foo; }', errors: [
+      expectedError(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE, 10, 6)
+    ]);
+  }
+
+  void test_exportDirectiveAfterPartDirective() {
+    parseCompilationUnit("part 'a.dart'; export 'b.dart';", errors: [
+      expectedError(
+          ParserErrorCode.EXPORT_DIRECTIVE_AFTER_PART_DIRECTIVE, 15, 6)
+    ]);
+  }
+
+  void test_externalAfterConst() {
+    createParser('const external C();');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 6, 8)]);
+  }
+
+  void test_externalAfterFactory() {
+    createParser('factory external C();');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 8, 8)]);
+  }
+
+  void test_externalAfterStatic() {
+    createParser('static external int m();');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 7, 8)]);
+  }
+
+  void test_externalClass() {
+    parseCompilationUnit("external class C {}",
+        errors: [expectedError(ParserErrorCode.EXTERNAL_CLASS, 0, 8)]);
+  }
+
+  void test_externalConstructorWithBody_factory() {
+    createParser('external factory C() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.EXTERNAL_FACTORY_WITH_BODY, 21, 1)]);
+  }
+
+  void test_externalConstructorWithBody_named() {
+    createParser('external C.c() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
+    listener.assertErrorsWithCodes([ParserErrorCode.EXTERNAL_METHOD_WITH_BODY]);
+//      listener.assertErrors(
+//          [expectedError(ParserErrorCode.EXTERNAL_METHOD_WITH_BODY, 15, 2)]);
+  }
+
+  void test_externalEnum() {
+    parseCompilationUnit("external enum E {ONE}",
+        errors: [expectedError(ParserErrorCode.EXTERNAL_ENUM, 0, 8)]);
+  }
+
+  void test_externalField_const() {
+    createParser('external const A f;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(CompileTimeErrorCode.CONST_NOT_INITIALIZED, 17, 1)]);
+  }
+
+  void test_externalField_final() {
+    createParser('external final A f;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    assertNoErrors();
+  }
+
+  void test_externalField_static() {
+    createParser('external static A f;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    assertNoErrors();
+  }
+
+  void test_externalField_typed() {
+    createParser('external A f;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    assertNoErrors();
+  }
+
+  void test_externalField_untyped() {
+    createParser('external var f;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    assertNoErrors();
+  }
+
+  void test_externalGetterWithBody() {
+    createParser('external int get x {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
+    listener.assertErrorsWithCodes([ParserErrorCode.EXTERNAL_METHOD_WITH_BODY]);
+//      listener.assertErrors(
+//          [expectedError(ParserErrorCode.EXTERNAL_METHOD_WITH_BODY, 19, 2)]);
+  }
+
+  void test_externalMethodWithBody() {
+    createParser('external m() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
+    listener.assertErrorsWithCodes([ParserErrorCode.EXTERNAL_METHOD_WITH_BODY]);
+//    listener.assertErrors(
+//        [expectedError(ParserErrorCode.EXTERNAL_METHOD_WITH_BODY, 13, 2)]);
+  }
+
+  void test_externalOperatorWithBody() {
+    createParser('external operator +(int value) {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
+    listener.assertErrorsWithCodes([ParserErrorCode.EXTERNAL_METHOD_WITH_BODY]);
+//      listener.assertErrors(
+//          [expectedError(ParserErrorCode.EXTERNAL_METHOD_WITH_BODY, 31, 2)]);
+  }
+
+  void test_externalSetterWithBody() {
+    createParser('external set x(int value) {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
+    listener.assertErrorsWithCodes([ParserErrorCode.EXTERNAL_METHOD_WITH_BODY]);
+//      listener.assertErrors(
+//          [expectedError(ParserErrorCode.EXTERNAL_METHOD_WITH_BODY, 26, 2)]);
+  }
+
+  void test_externalTypedef() {
+    parseCompilationUnit("external typedef F();",
+        errors: [expectedError(ParserErrorCode.EXTERNAL_TYPEDEF, 0, 8)]);
+  }
+
+  void test_extraCommaInParameterList() {
+    createParser('(int a, , int b)');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 1)]);
+  }
+
+  void test_extraCommaTrailingNamedParameterGroup() {
+    createParser('({int b},)');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 8, 1)]);
+  }
+
+  void test_extraCommaTrailingPositionalParameterGroup() {
+    createParser('([int b],)');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 8, 1)]);
+  }
+
+  void test_extraTrailingCommaInParameterList() {
+    createParser('(a,,)');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 3, 1)]);
+  }
+
+  void test_factory_issue_36400() {
+    parseCompilationUnit('class T { T factory T() { return null; } }',
+        errors: [expectedError(ParserErrorCode.TYPE_BEFORE_FACTORY, 10, 1)]);
+  }
+
+  void test_factoryTopLevelDeclaration_class() {
+    parseCompilationUnit("factory class C {}", errors: [
+      expectedError(ParserErrorCode.FACTORY_TOP_LEVEL_DECLARATION, 0, 7)
+    ]);
+  }
+
+  void test_factoryTopLevelDeclaration_enum() {
+    parseCompilationUnit("factory enum E { v }", errors: [
+      expectedError(ParserErrorCode.FACTORY_TOP_LEVEL_DECLARATION, 0, 7)
+    ]);
+  }
+
+  void test_factoryTopLevelDeclaration_typedef() {
+    parseCompilationUnit("factory typedef F();", errors: [
+      expectedError(ParserErrorCode.FACTORY_TOP_LEVEL_DECLARATION, 0, 7)
+    ]);
+  }
+
+  void test_factoryWithInitializers() {
+    createParser('factory C() : x = 3 {}', expectedEndOffset: 12);
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 12, 1)]);
+  }
+
+  void test_factoryWithoutBody() {
+    createParser('factory C();');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 11, 1)]);
+  }
+
+  void test_fieldInitializerOutsideConstructor() {
+    createParser('void m(this.x);');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR, 7, 4)
+    ]);
+  }
+
+  void test_finalAndCovariant() {
+    createParser('final covariant f = null;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 6, 9),
+      expectedError(ParserErrorCode.FINAL_AND_COVARIANT, 6, 9)
+    ]);
+  }
+
+  void test_finalAndVar() {
+    createParser('final var x = null;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([expectedError(ParserErrorCode.FINAL_AND_VAR, 6, 3)]);
+  }
+
+  void test_finalClass() {
+    parseCompilationUnit("final class C {}",
+        errors: [expectedError(ParserErrorCode.FINAL_CLASS, 0, 5)]);
+  }
+
+  void test_finalClassMember_modifierOnly() {
+    createParser('final');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 5, 0),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 5, 0)
+    ]);
+  }
+
+  void test_finalConstructor() {
+    createParser('final C() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.EXTRANEOUS_MODIFIER, 0, 5)]);
+  }
+
+  void test_finalEnum() {
+    parseCompilationUnit("final enum E {ONE}", errors: [
+      // Fasta interprets the `final` as a malformed top level final
+      // and `enum` as the start of a enum declaration.
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 4),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 6, 4),
+    ]);
+  }
+
+  void test_finalMethod() {
+    createParser('final int m() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.EXTRANEOUS_MODIFIER, 0, 5)]);
+  }
+
+  void test_finalTypedef() {
+    parseCompilationUnit("final typedef F();", errors: [
+      // Fasta interprets the `final` as a malformed top level final
+      // and `typedef` as the start of an typedef declaration.
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 7),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 6, 7),
+    ]);
+  }
+
+  void test_functionTypedField_invalidType_abstract() {
+    parseCompilationUnit("Function(abstract) x = null;", errors: [
+      expectedError(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE, 9, 8)
+    ]);
+  }
+
+  void test_functionTypedField_invalidType_class() {
+    parseCompilationUnit("Function(class) x = null;", errors: [
+      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 9, 5),
+      expectedError(ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD, 9, 5)
+    ]);
+  }
+
+  void test_functionTypedParameter_const() {
+    parseCompilationUnit("void f(const x()) {}", errors: [
+      expectedError(ParserErrorCode.EXTRANEOUS_MODIFIER, 7, 5),
+      expectedError(ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR, 7, 5)
+    ]);
+  }
+
+  void test_functionTypedParameter_final() {
+    parseCompilationUnit("void f(final x()) {}", errors: [
+      expectedError(ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR, 7, 5)
+    ]);
+  }
+
+  void test_functionTypedParameter_incomplete1() {
+    parseCompilationUnit("void f(int Function(", errors: [
+      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 20, 1),
+      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 20, 1),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 20, 0),
+    ]);
+  }
+
+  void test_functionTypedParameter_var() {
+    parseCompilationUnit("void f(var x()) {}", errors: [
+      expectedError(ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR, 7, 3)
+    ]);
+  }
+
+  void test_genericFunctionType_asIdentifier() {
+    createParser('final int Function = 0;');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    listener.assertErrors([]);
+  }
+
+  void test_genericFunctionType_asIdentifier2() {
+    createParser('int Function() {}');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    listener.assertErrors([]);
+  }
+
+  void test_genericFunctionType_asIdentifier3() {
+    createParser('int Function() => 0;');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    listener.assertErrors([]);
+  }
+
+  void test_genericFunctionType_extraLessThan() {
+    createParser('''
+class Wrong<T> {
+  T Function(<List<int> foo) bar;
+}''');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 30, 1),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 30, 1)
+    ]);
+  }
+
+  void test_getterInFunction_block_noReturnType() {
+    Statement result =
+        parseStatement("get x { return _x; }", expectedEndOffset: 4);
+    // Fasta considers `get` to be an identifier in this situation.
+    // TODO(danrubel): Investigate better recovery.
+    ExpressionStatement statement = result;
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 0, 3)]);
+    expect(statement.expression.toSource(), 'get');
+  }
+
+  void test_getterInFunction_block_returnType() {
+    // Fasta considers `get` to be an identifier in this situation.
+    parseStatement("int get x { return _x; }", expectedEndOffset: 8);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 4, 3)]);
+  }
+
+  void test_getterInFunction_expression_noReturnType() {
+    // Fasta considers `get` to be an identifier in this situation.
+    parseStatement("get x => _x;", expectedEndOffset: 4);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 0, 3)]);
+  }
+
+  void test_getterInFunction_expression_returnType() {
+    // Fasta considers `get` to be an identifier in this situation.
+    parseStatement("int get x => _x;", expectedEndOffset: 8);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 4, 3)]);
+  }
+
+  void test_getterNativeWithBody() {
+    createParser('String get m native "str" => 0;');
+    parser.parseClassMember('C') as MethodDeclaration;
+    if (!allowNativeClause) {
+      assertErrorsWithCodes([
+        ParserErrorCode.NATIVE_CLAUSE_SHOULD_BE_ANNOTATION,
+        ParserErrorCode.EXTERNAL_METHOD_WITH_BODY,
+      ]);
+    } else {
+      assertErrorsWithCodes([
+        ParserErrorCode.EXTERNAL_METHOD_WITH_BODY,
+      ]);
+    }
+  }
+
+  void test_getterWithParameters() {
+    createParser('int get x() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
+    listener.assertErrorsWithCodes([ParserErrorCode.GETTER_WITH_PARAMETERS]);
+//    listener.assertErrors(
+//        [expectedError(ParserErrorCode.GETTER_WITH_PARAMETERS, 9, 2)]);
+  }
+
+  void test_illegalAssignmentToNonAssignable_assign_int() {
+    parseStatement("0 = 1;");
+    listener.assertErrors([
+      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 0, 1),
+      expectedError(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 0, 1),
+    ]);
+  }
+
+  void test_illegalAssignmentToNonAssignable_assign_this() {
+    parseStatement("this = 1;");
+    listener.assertErrors([
+      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 0, 4),
+      expectedError(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 0, 4)
+    ]);
+  }
+
+  void test_illegalAssignmentToNonAssignable_postfix_minusMinus_literal() {
+    parseExpression("0--", errors: [
+      expectedError(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 1, 2)
+    ]);
+  }
+
+  void test_illegalAssignmentToNonAssignable_postfix_plusPlus_literal() {
+    parseExpression("0++", errors: [
+      expectedError(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 1, 2)
+    ]);
+  }
+
+  void test_illegalAssignmentToNonAssignable_postfix_plusPlus_parenthesized() {
+    parseExpression("(x)++", errors: [
+      expectedError(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 3, 2)
+    ]);
+  }
+
+  void test_illegalAssignmentToNonAssignable_primarySelectorPostfix() {
+    parseExpression("x(y)(z)++", errors: [
+      expectedError(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 7, 2)
+    ]);
+  }
+
+  void test_illegalAssignmentToNonAssignable_superAssigned() {
+    parseStatement("super = x;");
+    listener.assertErrors([
+      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 0, 5),
+      expectedError(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 0, 5)
+    ]);
+  }
+
+  void test_implementsBeforeExtends() {
+    parseCompilationUnit("class A implements B extends C {}", errors: [
+      expectedError(ParserErrorCode.IMPLEMENTS_BEFORE_EXTENDS, 21, 7)
+    ]);
+  }
+
+  void test_implementsBeforeWith() {
+    parseCompilationUnit("class A extends B implements C with D {}",
+        errors: [expectedError(ParserErrorCode.IMPLEMENTS_BEFORE_WITH, 31, 4)]);
+  }
+
+  void test_importDirectiveAfterPartDirective() {
+    parseCompilationUnit("part 'a.dart'; import 'b.dart';", errors: [
+      expectedError(
+          ParserErrorCode.IMPORT_DIRECTIVE_AFTER_PART_DIRECTIVE, 15, 6)
+    ]);
+  }
+
+  void test_initializedVariableInForEach() {
+    Statement statement = parseStatement('for (int a = 0 in foo) {}');
+    expectNotNullIfNoErrors(statement);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.INITIALIZED_VARIABLE_IN_FOR_EACH, 11, 1)
+    ]);
+  }
+
+  void test_initializedVariableInForEach_annotation() {
+    Statement statement = parseStatement('for (@Foo var a = 0 in foo) {}');
+    expectNotNullIfNoErrors(statement);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.INITIALIZED_VARIABLE_IN_FOR_EACH, 16, 1)
+    ]);
+  }
+
+  void test_initializedVariableInForEach_localFunction() {
+    Statement statement = parseStatement('for (f()) {}');
+    expectNotNullIfNoErrors(statement);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 1),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 8, 1)
+    ]);
+  }
+
+  void test_initializedVariableInForEach_localFunction2() {
+    Statement statement = parseStatement('for (T f()) {}');
+    expectNotNullIfNoErrors(statement);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 9, 1),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 9, 1)
+    ]);
+  }
+
+  void test_initializedVariableInForEach_var() {
+    Statement statement = parseStatement('for (var a = 0 in foo) {}');
+    expectNotNullIfNoErrors(statement);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.INITIALIZED_VARIABLE_IN_FOR_EACH, 11, 1)
+    ]);
+  }
+
+  void test_invalidAwaitInFor() {
+    Statement statement = parseStatement('await for (; ;) {}');
+    expectNotNullIfNoErrors(statement);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.INVALID_AWAIT_IN_FOR, 0, 5)]);
+  }
+
+  void test_invalidCodePoint() {
+    StringLiteral literal = parseExpression("'begin \\u{110000}'",
+        errors: [expectedError(ParserErrorCode.INVALID_CODE_POINT, 7, 9)]);
+    expectNotNullIfNoErrors(literal);
+  }
+
+  @failingTest
+  void test_invalidCommentReference__new_nonIdentifier() {
+    // This test fails because the method parseCommentReference returns null.
+    createParser('');
+    CommentReference reference = parseCommentReference('new 42', 0);
+    expectNotNullIfNoErrors(reference);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.INVALID_COMMENT_REFERENCE, 0, 6)]);
+  }
+
+  @failingTest
+  void test_invalidCommentReference__new_tooMuch() {
+    createParser('');
+    CommentReference reference = parseCommentReference('new a.b.c.d', 0);
+    expectNotNullIfNoErrors(reference);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.INVALID_COMMENT_REFERENCE, 0, 11)]);
+  }
+
+  @failingTest
+  void test_invalidCommentReference__nonNew_nonIdentifier() {
+    // This test fails because the method parseCommentReference returns null.
+    createParser('');
+    CommentReference reference = parseCommentReference('42', 0);
+    expectNotNullIfNoErrors(reference);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.INVALID_COMMENT_REFERENCE, 0, 2)]);
+  }
+
+  @failingTest
+  void test_invalidCommentReference__nonNew_tooMuch() {
+    createParser('');
+    CommentReference reference = parseCommentReference('a.b.c.d', 0);
+    expectNotNullIfNoErrors(reference);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.INVALID_COMMENT_REFERENCE, 0, 7)]);
+  }
+
+  void test_invalidConstructorName_star() {
+    createParser("C.*();");
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 2, 1)]);
+  }
+
+  void test_invalidConstructorName_with() {
+    createParser("C.with();");
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD, 2, 4)
+    ]);
+  }
+
+  void test_invalidConstructorSuperAssignment() {
+    createParser("C() : super = 42;");
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 6, 5)]);
+  }
+
+  void test_invalidConstructorSuperFieldAssignment() {
+    createParser("C() : super.a = 42;");
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([
+      expectedError(
+          ParserErrorCode.FIELD_INITIALIZED_OUTSIDE_DECLARING_CLASS, 12, 1)
+    ]);
+  }
+
+  void test_invalidHexEscape_invalidDigit() {
+    StringLiteral literal = parseExpression("'not \\x0 a'",
+        errors: [expectedError(ParserErrorCode.INVALID_HEX_ESCAPE, 5, 3)]);
+    expectNotNullIfNoErrors(literal);
+  }
+
+  void test_invalidHexEscape_tooFewDigits() {
+    StringLiteral literal = parseExpression("'\\x0'",
+        errors: [expectedError(ParserErrorCode.INVALID_HEX_ESCAPE, 1, 3)]);
+    expectNotNullIfNoErrors(literal);
+  }
+
+  void test_invalidInlineFunctionType() {
+    parseCompilationUnit(
+      'typedef F = int Function(int a());',
+      errors: [
+        expectedError(CompileTimeErrorCode.INVALID_INLINE_FUNCTION_TYPE, 30, 1)
+      ],
+    );
+  }
+
+  void test_invalidInterpolation_missingClosingBrace_issue35900() {
+    parseCompilationUnit(r"main () { print('${x' '); }", errors: [
+      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 23, 1),
+      expectedError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 26, 1),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 20, 3),
+      expectedError(ParserErrorCode.EXPECTED_STRING_LITERAL, 23, 1),
+      expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 27, 0),
+    ]);
+  }
+
+  void test_invalidInterpolationIdentifier_startWithDigit() {
+    StringLiteral literal = parseExpression("'\$1'",
+        errors: [expectedError(ScannerErrorCode.MISSING_IDENTIFIER, 2, 1)]);
+    expectNotNullIfNoErrors(literal);
+  }
+
+  void test_invalidLiteralInConfiguration() {
+    createParser("if (a == 'x \$y z') 'a.dart'");
+    Configuration configuration = parser.parseConfiguration();
+    expectNotNullIfNoErrors(configuration);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.INVALID_LITERAL_IN_CONFIGURATION, 12, 2)
+    ]);
+  }
+
+  void test_invalidOperator() {
+    CompilationUnit unit = parseCompilationUnit(
+        'class C { void operator ===(x) { } }',
+        errors: [expectedError(ScannerErrorCode.UNSUPPORTED_OPERATOR, 24, 1)]);
+    expect(unit, isNotNull);
+  }
+
+  void test_invalidOperator_unary() {
+    createParser('class C { int operator unary- => 0; }');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 23, 5),
+      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 28, 1)
+    ]);
+  }
+
+  void test_invalidOperatorAfterSuper_assignableExpression() {
+    Expression expression = parseAssignableExpression('super?.v', false);
+    expectNotNullIfNoErrors(expression);
+    listener.assertErrors([
+      expectedError(
+          ParserErrorCode.INVALID_OPERATOR_QUESTIONMARK_PERIOD_FOR_SUPER, 5, 2)
+    ]);
+  }
+
+  void test_invalidOperatorAfterSuper_constructorInitializer2() {
+    parseCompilationUnit('class C { C() : super?.namedConstructor(); }',
+        errors: [
+          expectedError(
+              ParserErrorCode.INVALID_OPERATOR_QUESTIONMARK_PERIOD_FOR_SUPER,
+              21,
+              2)
+        ]);
+  }
+
+  void test_invalidOperatorAfterSuper_primaryExpression() {
+    Expression expression = parseExpression('super?.v', errors: [
+      expectedError(
+          ParserErrorCode.INVALID_OPERATOR_QUESTIONMARK_PERIOD_FOR_SUPER, 5, 2)
+    ]);
+    expectNotNullIfNoErrors(expression);
+  }
+
+  void test_invalidOperatorForSuper() {
+    createParser('++super');
+    Expression expression = parser.parseUnaryExpression();
+    expectNotNullIfNoErrors(expression);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 2, 5)]);
+  }
+
+  void test_invalidPropertyAccess_this() {
+    parseExpression('x.this',
+        errors: [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 2, 4)]);
+  }
+
+  void test_invalidStarAfterAsync() {
+    createParser('foo() async* => 0;');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    listener.assertErrors(
+        [expectedError(CompileTimeErrorCode.RETURN_IN_GENERATOR, 13, 2)]);
+  }
+
+  void test_invalidSync() {
+    createParser('foo() sync* => 0;');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    listener.assertErrors(
+        [expectedError(CompileTimeErrorCode.RETURN_IN_GENERATOR, 12, 2)]);
+  }
+
+  void test_invalidTopLevelSetter() {
+    parseCompilationUnit("var set foo; main(){}", errors: [
+      expectedError(ParserErrorCode.VAR_RETURN_TYPE, 0, 3),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 8, 3),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 11, 1)
+    ]);
+  }
+
+  void test_invalidTopLevelVar() {
+    parseCompilationUnit("var Function(var arg);", errors: [
+      expectedError(ParserErrorCode.VAR_RETURN_TYPE, 0, 3),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 21, 1),
+    ]);
+  }
+
+  void test_invalidTypedef() {
+    parseCompilationUnit("typedef var Function(var arg);", errors: [
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 3),
+      expectedError(ParserErrorCode.MISSING_TYPEDEF_PARAMETERS, 8, 3),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 8, 3),
+      expectedError(ParserErrorCode.VAR_RETURN_TYPE, 8, 3),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 29, 1),
+    ]);
+  }
+
+  void test_invalidTypedef2() {
+    // https://github.com/dart-lang/sdk/issues/31171
+    parseCompilationUnit(
+        "typedef T = typedef F = Map<String, dynamic> Function();",
+        errors: [
+          expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 12, 7),
+          expectedError(ParserErrorCode.EXPECTED_TOKEN, 12, 7),
+          expectedError(ParserErrorCode.INVALID_GENERIC_FUNCTION_TYPE, 10, 1),
+        ]);
+  }
+
+  void test_invalidUnicodeEscape_incomplete_noDigits() {
+    Expression expression = parseStringLiteral("'\\u{'");
+    expectNotNullIfNoErrors(expression);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.INVALID_UNICODE_ESCAPE, 1, 3)]);
+  }
+
+  void test_invalidUnicodeEscape_incomplete_someDigits() {
+    Expression expression = parseStringLiteral("'\\u{0A'");
+    expectNotNullIfNoErrors(expression);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.INVALID_UNICODE_ESCAPE, 1, 5)]);
+  }
+
+  void test_invalidUnicodeEscape_invalidDigit() {
+    Expression expression = parseStringLiteral("'\\u0 and some more'");
+    expectNotNullIfNoErrors(expression);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.INVALID_UNICODE_ESCAPE, 1, 3)]);
+  }
+
+  void test_invalidUnicodeEscape_tooFewDigits_fixed() {
+    Expression expression = parseStringLiteral("'\\u04'");
+    expectNotNullIfNoErrors(expression);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.INVALID_UNICODE_ESCAPE, 1, 4)]);
+  }
+
+  void test_invalidUnicodeEscape_tooFewDigits_variable() {
+    Expression expression = parseStringLiteral("'\\u{}'");
+    expectNotNullIfNoErrors(expression);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.INVALID_UNICODE_ESCAPE, 1, 4)]);
+  }
+
+  void test_invalidUnicodeEscape_tooManyDigits_variable() {
+    Expression expression = parseStringLiteral("'\\u{12345678}'");
+    expectNotNullIfNoErrors(expression);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.INVALID_CODE_POINT, 1, 9)]);
+  }
+
+  void test_libraryDirectiveNotFirst() {
+    parseCompilationUnit("import 'x.dart'; library l;", errors: [
+      expectedError(ParserErrorCode.LIBRARY_DIRECTIVE_NOT_FIRST, 17, 7)
+    ]);
+  }
+
+  void test_libraryDirectiveNotFirst_afterPart() {
+    CompilationUnit unit = parseCompilationUnit("part 'a.dart';\nlibrary l;",
+        errors: [
+          expectedError(ParserErrorCode.LIBRARY_DIRECTIVE_NOT_FIRST, 15, 7)
+        ]);
+    expect(unit, isNotNull);
+  }
+
+  void test_localFunction_annotation() {
+    CompilationUnit unit =
+        parseCompilationUnit("class C { m() { @Foo f() {} } }");
+    expect(unit.declarations, hasLength(1));
+    ClassDeclaration declaration = unit.declarations[0];
+    expect(declaration.members, hasLength(1));
+    MethodDeclaration member = declaration.members[0];
+    BlockFunctionBody body = member.body;
+    expect(body.block.statements, hasLength(1));
+    FunctionDeclarationStatement statement = body.block.statements[0];
+    expect(statement.functionDeclaration.metadata, hasLength(1));
+    Annotation metadata = statement.functionDeclaration.metadata[0];
+    expect(metadata.name.name, 'Foo');
+  }
+
+  void test_localFunctionDeclarationModifier_abstract() {
+    parseCompilationUnit("class C { m() { abstract f() {} } }",
+        errors: [expectedError(ParserErrorCode.EXTRANEOUS_MODIFIER, 16, 8)]);
+  }
+
+  void test_localFunctionDeclarationModifier_external() {
+    parseCompilationUnit("class C { m() { external f() {} } }",
+        errors: [expectedError(ParserErrorCode.EXTRANEOUS_MODIFIER, 16, 8)]);
+  }
+
+  void test_localFunctionDeclarationModifier_factory() {
+    parseCompilationUnit("class C { m() { factory f() {} } }",
+        errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 16, 7)]);
+  }
+
+  void test_localFunctionDeclarationModifier_static() {
+    parseCompilationUnit("class C { m() { static f() {} } }",
+        errors: [expectedError(ParserErrorCode.EXTRANEOUS_MODIFIER, 16, 6)]);
+  }
+
+  void test_method_invalidTypeParameterExtends() {
+    // Regression test for https://github.com/dart-lang/sdk/issues/25739.
+
+    // TODO(jmesserly): ideally we'd be better at parser recovery here.
+    createParser('f<E>(E extends num p);');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 7)]);
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.parameters.toString(), '(E)',
+        reason: 'parser recovers what it can');
+  }
+
+  void test_method_invalidTypeParameters() {
+    createParser('void m<E, hello!>() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 10, 5)]);
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.typeParameters.toString(), '<E, hello>',
+        reason: 'parser recovers what it can');
+  }
+
+  void test_missing_closing_bracket_issue37528() {
+    final code = '\${foo';
+    createParser(code);
+    final result = fasta.scanString(code);
+    expect(result.hasErrors, isTrue);
+    var token = parserProxy.fastaParser.syntheticPreviousToken(result.tokens);
+    try {
+      parserProxy.fastaParser.parseExpression(token);
+      // TODO(danrubel): Replace this test once root cause is found
+      fail('exception expected');
+    } catch (e) {
+      var msg = e.toString();
+      expect(msg.contains('test_missing_closing_bracket_issue37528'), isTrue);
+    }
+  }
+
+  void test_missingAssignableSelector_identifiersAssigned() {
+    parseExpression("x.y = y;", expectedEndOffset: 7);
+  }
+
+  void test_missingAssignableSelector_prefix_minusMinus_literal() {
+    parseExpression("--0", errors: [
+      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 2, 1)
+    ]);
+  }
+
+  void test_missingAssignableSelector_prefix_plusPlus_literal() {
+    parseExpression("++0", errors: [
+      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 2, 1)
+    ]);
+  }
+
+  void test_missingAssignableSelector_selector() {
+    parseExpression("x(y)(z).a++");
+  }
+
+  void test_missingAssignableSelector_superPrimaryExpression() {
+    CompilationUnit unit = parseCompilationUnit('main() {super;}', errors: [
+      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 8, 5)
+    ]);
+    FunctionDeclaration declaration = unit.declarations.first;
+    BlockFunctionBody blockBody = declaration.functionExpression.body;
+    ExpressionStatement statement = blockBody.block.statements.first;
+    Expression expression = statement.expression;
+    expect(expression, isSuperExpression);
+    SuperExpression superExpression = expression;
+    expect(superExpression.superKeyword, isNotNull);
+  }
+
+  void test_missingAssignableSelector_superPropertyAccessAssigned() {
+    parseExpression("super.x = x;", expectedEndOffset: 11);
+  }
+
+  void test_missingCatchOrFinally() {
+    TryStatement statement = parseStatement('try {}');
+    expectNotNullIfNoErrors(statement);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_CATCH_OR_FINALLY, 0, 3)]);
+    expect(statement, isNotNull);
+  }
+
+  void test_missingClosingParenthesis() {
+    createParser('(int a, int b ;',
+        expectedEndOffset: 14 /* parsing ends at synthetic ')' */);
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    listener.errors
+        .contains(expectedError(ParserErrorCode.EXPECTED_TOKEN, 14, 1));
+  }
+
+  void test_missingConstFinalVarOrType_static() {
+    parseCompilationUnit("class A { static f; }", errors: [
+      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 17, 1)
+    ]);
+  }
+
+  void test_missingConstFinalVarOrType_topLevel() {
+    parseCompilationUnit('a;', errors: [
+      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 0, 1)
+    ]);
+  }
+
+  void test_missingEnumBody() {
+    createParser('enum E;', expectedEndOffset: 6);
+    EnumDeclaration declaration = parseFullCompilationUnitMember();
+    expectNotNullIfNoErrors(declaration);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.MISSING_ENUM_BODY, 6, 1)]);
+  }
+
+  void test_missingEnumComma() {
+    createParser('enum E {one two}');
+    EnumDeclaration declaration = parseFullCompilationUnitMember();
+    expectNotNullIfNoErrors(declaration);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 12, 3)]);
+  }
+
+  void test_missingExpressionInThrow() {
+    ThrowExpression expression =
+        (parseStatement('throw;') as ExpressionStatement).expression;
+    expectNotNullIfNoErrors(expression);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_EXPRESSION_IN_THROW, 5, 1)]);
+  }
+
+  void test_missingFunctionBody_emptyNotAllowed() {
+    createParser(';');
+    FunctionBody functionBody = parser.parseFunctionBody(
+        false, ParserErrorCode.MISSING_FUNCTION_BODY, false);
+    expectNotNullIfNoErrors(functionBody);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 0, 1)]);
+  }
+
+  void test_missingFunctionBody_invalid() {
+    createParser('return 0;');
+    FunctionBody functionBody = parser.parseFunctionBody(
+        false, ParserErrorCode.MISSING_FUNCTION_BODY, false);
+    expectNotNullIfNoErrors(functionBody);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 0, 6)]);
+  }
+
+  void test_missingFunctionParameters_local_nonVoid_block() {
+    // The parser does not recognize this as a function declaration, so it tries
+    // to parse it as an expression statement. It isn't clear what the best
+    // error message is in this case.
+    parseStatement("int f { return x;}", expectedEndOffset: 6);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 4, 1)]);
+  }
+
+  void test_missingFunctionParameters_local_nonVoid_expression() {
+    // The parser does not recognize this as a function declaration, so it tries
+    // to parse it as an expression statement. It isn't clear what the best
+    // error message is in this case.
+    parseStatement("int f => x;");
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 6, 2)]);
+  }
+
+  void test_missingFunctionParameters_local_void_block() {
+    parseStatement("void f { return x;}", expectedEndOffset: 7);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 5, 1)]);
+  }
+
+  void test_missingFunctionParameters_local_void_expression() {
+    parseStatement("void f => x;");
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 7, 2)]);
+  }
+
+  void test_missingFunctionParameters_topLevel_nonVoid_block() {
+    parseCompilationUnit("int f { return x;}", errors: [
+      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 4, 1)
+    ]);
+  }
+
+  void test_missingFunctionParameters_topLevel_nonVoid_expression() {
+    parseCompilationUnit("int f => x;", errors: [
+      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 4, 1)
+    ]);
+  }
+
+  void test_missingFunctionParameters_topLevel_void_block() {
+    CompilationUnit unit = parseCompilationUnit("void f { return x;}", errors: [
+      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 5, 1)
+    ]);
+    FunctionDeclaration funct = unit.declarations[0];
+    expect(funct.functionExpression.parameters, hasLength(0));
+  }
+
+  void test_missingFunctionParameters_topLevel_void_expression() {
+    CompilationUnit unit = parseCompilationUnit("void f => x;", errors: [
+      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 5, 1)
+    ]);
+    FunctionDeclaration funct = unit.declarations[0];
+    expect(funct.functionExpression.parameters, hasLength(0));
+  }
+
+  void test_missingIdentifier_afterOperator() {
+    createParser('1 *');
+    BinaryExpression expression = parser.parseMultiplicativeExpression();
+    expectNotNullIfNoErrors(expression);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 3, 0)]);
+  }
+
+  void test_missingIdentifier_beforeClosingCurly() {
+    createParser('int}', expectedEndOffset: 3);
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 0, 3),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 0, 3)
+    ]);
+  }
+
+  void test_missingIdentifier_inEnum() {
+    createParser('enum E {, TWO}');
+    EnumDeclaration declaration = parseFullCompilationUnitMember();
+    expectNotNullIfNoErrors(declaration);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 1)]);
+  }
+
+  void test_missingIdentifier_inParameterGroupNamed() {
+    createParser('(a, {})');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 5, 1)]);
+  }
+
+  void test_missingIdentifier_inParameterGroupOptional() {
+    createParser('(a, [])');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 5, 1)]);
+  }
+
+  void test_missingIdentifier_inSymbol_afterPeriod() {
+    SymbolLiteral literal = parseSymbolLiteral('#a.');
+    expectNotNullIfNoErrors(literal);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 3, 1)]);
+  }
+
+  void test_missingIdentifier_inSymbol_first() {
+    SymbolLiteral literal = parseSymbolLiteral('#');
+    expectNotNullIfNoErrors(literal);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 1, 1)]);
+  }
+
+  void test_missingIdentifierForParameterGroup() {
+    createParser('(,)');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 1, 1)]);
+  }
+
+  void test_missingKeywordOperator() {
+    createParser('+(x) {}');
+    MethodDeclaration method = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(method);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_KEYWORD_OPERATOR, 0, 1)]);
+  }
+
+  void test_missingKeywordOperator_parseClassMember() {
+    createParser('+() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_KEYWORD_OPERATOR, 0, 1)]);
+  }
+
+  void test_missingKeywordOperator_parseClassMember_afterTypeName() {
+    createParser('int +() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_KEYWORD_OPERATOR, 4, 1)]);
+  }
+
+  void test_missingKeywordOperator_parseClassMember_afterVoid() {
+    createParser('void +() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_KEYWORD_OPERATOR, 5, 1)]);
+  }
+
+  void test_missingMethodParameters_void_block() {
+    createParser('void m {} }', expectedEndOffset: 10);
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 5, 1)]);
+    expect(member, isMethodDeclaration);
+    MethodDeclaration method = member;
+    expect(method.parameters, hasLength(0));
+  }
+
+  void test_missingMethodParameters_void_expression() {
+    createParser('void m => null; }', expectedEndOffset: 16);
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 5, 1)]);
+  }
+
+  void test_missingNameForNamedParameter_colon() {
+    createParser('({int : 0})');
+    FormalParameter parameter =
+        parser.parseFormalParameterList(inFunctionType: true).parameters[0];
+    expectNotNullIfNoErrors(parameter);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 1),
+      expectedError(ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE, 6, 1)
+    ]);
+    expect(parameter.identifier, isNotNull);
+  }
+
+  void test_missingNameForNamedParameter_equals() {
+    createParser('({int = 0})');
+    FormalParameter parameter =
+        parser.parseFormalParameterList(inFunctionType: true).parameters[0];
+    expectNotNullIfNoErrors(parameter);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 1),
+      expectedError(ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE, 6, 1)
+    ]);
+    expect(parameter.identifier, isNotNull);
+  }
+
+  void test_missingNameForNamedParameter_noDefault() {
+    createParser('({int})');
+    FormalParameter parameter =
+        parser.parseFormalParameterList(inFunctionType: true).parameters[0];
+    expectNotNullIfNoErrors(parameter);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 5, 1)]);
+    expect(parameter.identifier, isNotNull);
+  }
+
+  void test_missingNameInLibraryDirective() {
+    CompilationUnit unit = parseCompilationUnit("library;",
+        errors: [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 7, 1)]);
+    expect(unit, isNotNull);
+  }
+
+  void test_missingNameInPartOfDirective() {
+    CompilationUnit unit = parseCompilationUnit("part of;",
+        errors: [expectedError(ParserErrorCode.EXPECTED_STRING_LITERAL, 7, 1)]);
+    expect(unit, isNotNull);
+  }
+
+  void test_missingPrefixInDeferredImport() {
+    parseCompilationUnit("import 'foo.dart' deferred;", errors: [
+      expectedError(ParserErrorCode.MISSING_PREFIX_IN_DEFERRED_IMPORT, 18, 8)
+    ]);
+  }
+
+  void test_missingStartAfterSync() {
+    createParser('sync {}');
+    FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
+    expectNotNullIfNoErrors(functionBody);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_STAR_AFTER_SYNC, 0, 4)]);
+  }
+
+  void test_missingStatement() {
+    parseStatement("is");
+    listener.assertErrors([
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 0, 2),
+      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 2, 0),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 2, 0)
+    ]);
+  }
+
+  void test_missingStatement_afterVoid() {
+    parseStatement("void;");
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 4, 1)]);
+  }
+
+  void test_missingTerminatorForParameterGroup_named() {
+    createParser('(a, {b: 0)');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    listener
+        .assertErrors([expectedError(ScannerErrorCode.EXPECTED_TOKEN, 9, 1)]);
+  }
+
+  void test_missingTerminatorForParameterGroup_optional() {
+    createParser('(a, [b = 0)');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    listener
+        .assertErrors([expectedError(ScannerErrorCode.EXPECTED_TOKEN, 10, 1)]);
+  }
+
+  void test_missingTypedefParameters_nonVoid() {
+    parseCompilationUnit("typedef int F;", errors: [
+      expectedError(ParserErrorCode.MISSING_TYPEDEF_PARAMETERS, 13, 1)
+    ]);
+  }
+
+  void test_missingTypedefParameters_typeParameters() {
+    parseCompilationUnit("typedef F<E>;", errors: [
+      expectedError(ParserErrorCode.MISSING_TYPEDEF_PARAMETERS, 12, 1)
+    ]);
+  }
+
+  void test_missingTypedefParameters_void() {
+    parseCompilationUnit("typedef void F;", errors: [
+      expectedError(ParserErrorCode.MISSING_TYPEDEF_PARAMETERS, 14, 1)
+    ]);
+  }
+
+  void test_missingVariableInForEach() {
+    Statement statement = parseStatement('for (a < b in foo) {}');
+    expectNotNullIfNoErrors(statement);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 7, 1)]);
+  }
+
+  void test_mixedParameterGroups_namedPositional() {
+    createParser('(a, {b}, [c])');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
+  }
+
+  void test_mixedParameterGroups_positionalNamed() {
+    createParser('(a, [b], {c})');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
+  }
+
+  void test_mixin_application_lacks_with_clause() {
+    parseCompilationUnit("class Foo = Bar;",
+        errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 15, 1)]);
+  }
+
+  void test_multipleExtendsClauses() {
+    parseCompilationUnit("class A extends B extends C {}", errors: [
+      expectedError(ParserErrorCode.MULTIPLE_EXTENDS_CLAUSES, 18, 7)
+    ]);
+  }
+
+  void test_multipleImplementsClauses() {
+    parseCompilationUnit("class A implements B implements C {}", errors: [
+      expectedError(ParserErrorCode.MULTIPLE_IMPLEMENTS_CLAUSES, 21, 10)
+    ]);
+  }
+
+  void test_multipleLibraryDirectives() {
+    parseCompilationUnit("library l; library m;", errors: [
+      expectedError(ParserErrorCode.MULTIPLE_LIBRARY_DIRECTIVES, 11, 7)
+    ]);
+  }
+
+  void test_multipleNamedParameterGroups() {
+    createParser('(a, {b}, {c})');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
+  }
+
+  void test_multiplePartOfDirectives() {
+    parseCompilationUnit("part of l; part of m;", errors: [
+      expectedError(ParserErrorCode.MULTIPLE_PART_OF_DIRECTIVES, 11, 4)
+    ]);
+  }
+
+  void test_multiplePositionalParameterGroups() {
+    createParser('(a, [b], [c])');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
+  }
+
+  void test_multipleVariablesInForEach() {
+    Statement statement = parseStatement('for (int a, b in foo) {}');
+    expectNotNullIfNoErrors(statement);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 10, 1)]);
+  }
+
+  void test_multipleWithClauses() {
+    parseCompilationUnit("class A extends B with C with D {}",
+        errors: [expectedError(ParserErrorCode.MULTIPLE_WITH_CLAUSES, 25, 4)]);
+  }
+
+  void test_namedFunctionExpression() {
+    Expression expression;
+    createParser('f() {}');
+    expression = parser.parsePrimaryExpression();
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.NAMED_FUNCTION_EXPRESSION, 0, 1)]);
+    expect(expression, isFunctionExpression);
+  }
+
+  void test_namedParameterOutsideGroup() {
+    createParser('(a, b : 0)');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.NAMED_PARAMETER_OUTSIDE_GROUP, 6, 1)]);
+    expect(list.parameters[0].isRequired, isTrue);
+    expect(list.parameters[1].isNamed, isTrue);
+  }
+
+  void test_nonConstructorFactory_field() {
+    createParser('factory int x;', expectedEndOffset: 12);
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 12, 1),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 12, 1)
+    ]);
+  }
+
+  void test_nonConstructorFactory_method() {
+    createParser('factory int m() {}', expectedEndOffset: 12);
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 12, 1),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 12, 1)
+    ]);
+  }
+
+  void test_nonIdentifierLibraryName_library() {
+    CompilationUnit unit = parseCompilationUnit("library 'lib';",
+        errors: [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 5)]);
+    expect(unit, isNotNull);
+  }
+
+  void test_nonIdentifierLibraryName_partOf() {
+    CompilationUnit unit = parseCompilationUnit("part of 3;", errors: [
+      expectedError(ParserErrorCode.EXPECTED_STRING_LITERAL, 8, 1),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 8, 1),
+      expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 8, 1),
+      expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 9, 1)
+    ]);
+    expect(unit, isNotNull);
+  }
+
+  void test_nonPartOfDirectiveInPart_after() {
+    parseCompilationUnit("part of l; part 'f.dart';", errors: [
+      expectedError(ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART, 11, 4)
+    ]);
+  }
+
+  void test_nonPartOfDirectiveInPart_before() {
+    // TODO(brianwilkerson) Remove codes when highlighting is fixed.
+    parseCompilationUnit("part 'f.dart'; part of m;", codes: [
+      ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART
+    ], errors: [
+      expectedError(ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART, 0, 4)
+    ]);
+  }
+
+  void test_nonUserDefinableOperator() {
+    createParser('operator +=(int x) => x + 1;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.INVALID_OPERATOR, 9, 2)]);
+  }
+
+  void test_optionalAfterNormalParameters_named() {
+    parseCompilationUnit("f({a}, b) {}",
+        errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 5, 1)]);
+  }
+
+  void test_optionalAfterNormalParameters_positional() {
+    parseCompilationUnit("f([a], b) {}",
+        errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 5, 1)]);
+  }
+
+  void test_parseCascadeSection_missingIdentifier() {
+    MethodInvocation methodInvocation = parseCascadeSection('..()');
+    expectNotNullIfNoErrors(methodInvocation);
+    listener.assertErrors([
+      // Cascade section is preceded by `null` in this test
+      // and error is reported on '('.
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 1)
+    ]);
+    expect(methodInvocation.target, isNull);
+    expect(methodInvocation.methodName.name, "");
+    expect(methodInvocation.typeArguments, isNull);
+    expect(methodInvocation.argumentList.arguments, hasLength(0));
+  }
+
+  void test_parseCascadeSection_missingIdentifier_typeArguments() {
+    MethodInvocation methodInvocation = parseCascadeSection('..<E>()');
+    expectNotNullIfNoErrors(methodInvocation);
+    listener.assertErrors([
+      // Cascade section is preceded by `null` in this test
+      // and error is reported on '<'.
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 1)
+    ]);
+    expect(methodInvocation.target, isNull);
+    expect(methodInvocation.methodName.name, "");
+    expect(methodInvocation.typeArguments, isNotNull);
+    expect(methodInvocation.argumentList.arguments, hasLength(0));
+  }
+
+  void test_partialNamedConstructor() {
+    parseCompilationUnit('class C { C. }', errors: [
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 13, 1),
+      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 10, 1),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 13, 1),
+    ]);
+  }
+
+  void test_positionalAfterNamedArgument() {
+    createParser('(x: 1, 2)');
+    ArgumentList list = parser.parseArgumentList();
+    expectNotNullIfNoErrors(list);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.POSITIONAL_AFTER_NAMED_ARGUMENT, 7, 1)]);
+  }
+
+  void test_positionalParameterOutsideGroup() {
+    createParser('(a, b = 0)');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.NAMED_PARAMETER_OUTSIDE_GROUP, 6, 1)]);
+    expect(list.parameters[0].isRequired, isTrue);
+    expect(list.parameters[1].isNamed, isTrue);
+  }
+
+  void test_redirectingConstructorWithBody_named() {
+    createParser('C.x() : this() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.REDIRECTING_CONSTRUCTOR_WITH_BODY, 15, 1)
+    ]);
+  }
+
+  void test_redirectingConstructorWithBody_unnamed() {
+    createParser('C() : this.x() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.REDIRECTING_CONSTRUCTOR_WITH_BODY, 15, 1)
+    ]);
+  }
+
+  void test_redirectionInNonFactoryConstructor() {
+    createParser('C() = D;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([
+      expectedError(
+          ParserErrorCode.REDIRECTION_IN_NON_FACTORY_CONSTRUCTOR, 4, 1)
+    ]);
+  }
+
+  void test_setterInFunction_block() {
+    parseStatement("set x(v) {_x = v;}");
+    listener
+        .assertErrors([expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 0, 3)]);
+  }
+
+  void test_setterInFunction_expression() {
+    parseStatement("set x(v) => _x = v;");
+    listener
+        .assertErrors([expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 0, 3)]);
+  }
+
+  void test_staticAfterConst() {
+    createParser('final static int f;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 6, 6)]);
+  }
+
+  void test_staticAfterFinal() {
+    createParser('const static int f;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 6, 6),
+      expectedError(CompileTimeErrorCode.CONST_NOT_INITIALIZED, 17, 1)
+    ]);
+  }
+
+  void test_staticAfterVar() {
+    createParser('var static f;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 4, 6)]);
+  }
+
+  void test_staticConstructor() {
+    createParser('static C.m() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.STATIC_CONSTRUCTOR, 0, 6)]);
+  }
+
+  void test_staticGetterWithoutBody() {
+    createParser('static get m;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 12, 1)]);
+  }
+
+  void test_staticOperator_noReturnType() {
+    createParser('static operator +(int x) => x + 1;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.STATIC_OPERATOR, 0, 6)]);
+  }
+
+  void test_staticOperator_returnType() {
+    createParser('static int operator +(int x) => x + 1;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.STATIC_OPERATOR, 0, 6)]);
+  }
+
+  void test_staticOperatorNamedMethod() {
+    // operator can be used as a method name
+    parseCompilationUnit('class C { static operator(x) => x; }');
+  }
+
+  void test_staticSetterWithoutBody() {
+    createParser('static set m(x);');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 15, 1)]);
+  }
+
+  void test_staticTopLevelDeclaration_class() {
+    parseCompilationUnit("static class C {}", errors: [
+      expectedError(ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION, 0, 6)
+    ]);
+  }
+
+  void test_staticTopLevelDeclaration_enum() {
+    parseCompilationUnit("static enum E { v }", errors: [
+      expectedError(ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION, 0, 6)
+    ]);
+  }
+
+  void test_staticTopLevelDeclaration_function() {
+    parseCompilationUnit("static f() {}", errors: [
+      expectedError(ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION, 0, 6)
+    ]);
+  }
+
+  void test_staticTopLevelDeclaration_typedef() {
+    parseCompilationUnit("static typedef F();", errors: [
+      expectedError(ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION, 0, 6)
+    ]);
+  }
+
+  void test_staticTopLevelDeclaration_variable() {
+    parseCompilationUnit("static var x;", errors: [
+      expectedError(ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION, 0, 6)
+    ]);
+  }
+
+  void test_string_unterminated_interpolation_block() {
+    parseCompilationUnit(r'''
+m() {
+ {
+ '${${
+''', codes: [
+      ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+      ScannerErrorCode.EXPECTED_TOKEN,
+      ScannerErrorCode.EXPECTED_TOKEN,
+      ScannerErrorCode.EXPECTED_TOKEN,
+      ScannerErrorCode.EXPECTED_TOKEN,
+      ParserErrorCode.EXPECTED_TOKEN,
+      ParserErrorCode.EXPECTED_TOKEN
+    ]);
+  }
+
+  void test_switchCase_missingColon() {
+    SwitchStatement statement = parseStatement('switch (a) {case 1 return 0;}');
+    expect(statement, isNotNull);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 19, 6)]);
+  }
+
+  void test_switchDefault_missingColon() {
+    SwitchStatement statement =
+        parseStatement('switch (a) {default return 0;}');
+    expect(statement, isNotNull);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 20, 6)]);
+  }
+
+  void test_switchHasCaseAfterDefaultCase() {
+    SwitchStatement statement =
+        parseStatement('switch (a) {default: return 0; case 1: return 1;}');
+    expectNotNullIfNoErrors(statement);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.SWITCH_HAS_CASE_AFTER_DEFAULT_CASE, 31, 4)
+    ]);
+  }
+
+  void test_switchHasCaseAfterDefaultCase_repeated() {
+    SwitchStatement statement = parseStatement(
+        'switch (a) {default: return 0; case 1: return 1; case 2: return 2;}');
+    expectNotNullIfNoErrors(statement);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.SWITCH_HAS_CASE_AFTER_DEFAULT_CASE, 31, 4),
+      expectedError(ParserErrorCode.SWITCH_HAS_CASE_AFTER_DEFAULT_CASE, 49, 4)
+    ]);
+  }
+
+  void test_switchHasMultipleDefaultCases() {
+    SwitchStatement statement =
+        parseStatement('switch (a) {default: return 0; default: return 1;}');
+    expectNotNullIfNoErrors(statement);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.SWITCH_HAS_MULTIPLE_DEFAULT_CASES, 31, 7)
+    ]);
+  }
+
+  void test_switchHasMultipleDefaultCases_repeated() {
+    SwitchStatement statement = parseStatement(
+        'switch (a) {default: return 0; default: return 1; default: return 2;}');
+    expectNotNullIfNoErrors(statement);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.SWITCH_HAS_MULTIPLE_DEFAULT_CASES, 31, 7),
+      expectedError(ParserErrorCode.SWITCH_HAS_MULTIPLE_DEFAULT_CASES, 50, 7)
+    ]);
+  }
+
+  void test_switchMissingBlock() {
+    SwitchStatement statement =
+        parseStatement('switch (a) return;', expectedEndOffset: 11);
+    expect(statement, isNotNull);
+    listener.assertErrors([expectedError(ParserErrorCode.EXPECTED_BODY, 9, 1)]);
+  }
+
+  void test_topLevel_getter() {
+    createParser('get x => 7;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expectNotNullIfNoErrors(member);
+    assertNoErrors();
+    expect(member, isFunctionDeclaration);
+    FunctionDeclaration function = member;
+    expect(function.functionExpression.parameters, isNull);
+  }
+
+  void test_topLevelFactory_withFunction() {
+    parseCompilationUnit('factory Function() x = null;', errors: [
+      expectedError(ParserErrorCode.FACTORY_TOP_LEVEL_DECLARATION, 0, 7)
+    ]);
+  }
+
+  void test_topLevelOperator_withFunction() {
+    parseCompilationUnit('operator Function() x = null;',
+        errors: [expectedError(ParserErrorCode.TOP_LEVEL_OPERATOR, 0, 8)]);
+  }
+
+  void test_topLevelOperator_withoutOperator() {
+    createParser('+(bool x, bool y) => x | y;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.TOP_LEVEL_OPERATOR, 0, 1)]);
+  }
+
+  void test_topLevelOperator_withoutType() {
+    parseCompilationUnit('operator +(bool x, bool y) => x | y;',
+        errors: [expectedError(ParserErrorCode.TOP_LEVEL_OPERATOR, 0, 8)]);
+  }
+
+  void test_topLevelOperator_withType() {
+    parseCompilationUnit('bool operator +(bool x, bool y) => x | y;',
+        errors: [expectedError(ParserErrorCode.TOP_LEVEL_OPERATOR, 5, 8)]);
+  }
+
+  void test_topLevelOperator_withVoid() {
+    parseCompilationUnit('void operator +(bool x, bool y) => x | y;',
+        errors: [expectedError(ParserErrorCode.TOP_LEVEL_OPERATOR, 5, 8)]);
+  }
+
+  void test_topLevelVariable_withMetadata() {
+    parseCompilationUnit("String @A string;", codes: [
+      ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE,
+      ParserErrorCode.EXPECTED_TOKEN,
+      ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE
+    ]);
+  }
+
+  void test_typedef_incomplete() {
+    // TODO(brianwilkerson) Improve recovery for this case.
+    parseCompilationUnit('''
+class A {}
+class B extends A {}
+
+typedef T
+
+main() {
+  Function<
+}
+''', errors: [
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 49, 1),
+      expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 51, 1),
+    ]);
+  }
+
+  void test_typedef_namedFunction() {
+    parseCompilationUnit('typedef void Function();',
+        codes: [ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD]);
+  }
+
+  void test_typedefInClass_withoutReturnType() {
+    parseCompilationUnit("class C { typedef F(x); }",
+        errors: [expectedError(ParserErrorCode.TYPEDEF_IN_CLASS, 10, 7)]);
+  }
+
+  void test_typedefInClass_withReturnType() {
+    parseCompilationUnit("class C { typedef int F(int x); }",
+        errors: [expectedError(ParserErrorCode.TYPEDEF_IN_CLASS, 10, 7)]);
+  }
+
+  void test_unexpectedCommaThenInterpolation() {
+    // https://github.com/Dart-Code/Dart-Code/issues/1548
+    parseCompilationUnit(r"main() { String s = 'a' 'b', 'c$foo'; return s; }",
+        errors: [
+          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 29, 2),
+          expectedError(ParserErrorCode.EXPECTED_TOKEN, 29, 2),
+        ]);
+  }
+
+  void test_unexpectedTerminatorForParameterGroup_named() {
+    createParser('(a, b})');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 5, 1)]);
+  }
+
+  void test_unexpectedTerminatorForParameterGroup_optional() {
+    createParser('(a, b])');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 5, 1)]);
+  }
+
+  void test_unexpectedToken_endOfFieldDeclarationStatement() {
+    parseStatement("String s = (null));", expectedEndOffset: 17);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 16, 1)]);
+  }
+
+  void test_unexpectedToken_invalidPostfixExpression() {
+    parseExpression("f()++", errors: [
+      expectedError(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 3, 2)
+    ]);
+  }
+
+  void test_unexpectedToken_invalidPrefixExpression() {
+    parseExpression("++f()", errors: [
+      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 4, 1)
+    ]);
+  }
+
+  void test_unexpectedToken_returnInExpressionFunctionBody() {
+    parseCompilationUnit("f() => return null;",
+        errors: [expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 7, 6)]);
+  }
+
+  void test_unexpectedToken_semicolonBetweenClassMembers() {
+    createParser('class C { int x; ; int y;}');
+    ClassDeclaration declaration = parseFullCompilationUnitMember();
+    expectNotNullIfNoErrors(declaration);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.EXPECTED_CLASS_MEMBER, 17, 1)]);
+  }
+
+  void test_unexpectedToken_semicolonBetweenCompilationUnitMembers() {
+    parseCompilationUnit("int x; ; int y;",
+        errors: [expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 7, 1)]);
+  }
+
+  void test_unterminatedString_at_eof() {
+    // Although the "unterminated string" error message is produced by the
+    // scanner, we need to verify that the parser can handle the tokens
+    // produced by the scanner when an unterminated string is encountered.
+    parseCompilationUnit(r'''
+void main() {
+  var x = "''', errors: [
+      expectedError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 24, 1),
+      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 25, 1),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 24, 1)
+    ]);
+  }
+
+  void test_unterminatedString_at_eol() {
+    // Although the "unterminated string" error message is produced by the
+    // scanner, we need to verify that the parser can handle the tokens
+    // produced by the scanner when an unterminated string is encountered.
+    parseCompilationUnit(r'''
+void main() {
+  var x = "
+;
+}
+''', errors: [
+      expectedError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 24, 1)
+    ]);
+  }
+
+  void test_unterminatedString_multiline_at_eof_3_quotes() {
+    // Although the "unterminated string" error message is produced by the
+    // scanner, we need to verify that the parser can handle the tokens
+    // produced by the scanner when an unterminated string is encountered.
+    // TODO(brianwilkerson) Remove codes when highlighting is fixed.
+    parseCompilationUnit(r'''
+void main() {
+  var x = """''', codes: [
+      ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+      ScannerErrorCode.EXPECTED_TOKEN,
+      ParserErrorCode.EXPECTED_TOKEN
+    ], errors: [
+      expectedError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 24, 1),
+      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 30, 0),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 30, 0)
+    ]);
+  }
+
+  void test_unterminatedString_multiline_at_eof_4_quotes() {
+    // Although the "unterminated string" error message is produced by the
+    // scanner, we need to verify that the parser can handle the tokens
+    // produced by the scanner when an unterminated string is encountered.
+    // TODO(brianwilkerson) Remove codes when highlighting is fixed.
+    parseCompilationUnit(r'''
+void main() {
+  var x = """"''', codes: [
+      ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+      ScannerErrorCode.EXPECTED_TOKEN,
+      ParserErrorCode.EXPECTED_TOKEN
+    ], errors: [
+      expectedError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 24, 1),
+      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 31, 0),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 31, 0)
+    ]);
+  }
+
+  void test_unterminatedString_multiline_at_eof_5_quotes() {
+    // Although the "unterminated string" error message is produced by the
+    // scanner, we need to verify that the parser can handle the tokens
+    // produced by the scanner when an unterminated string is encountered.
+    // TODO(brianwilkerson) Remove codes when highlighting is fixed.
+    parseCompilationUnit(r'''
+void main() {
+  var x = """""''', codes: [
+      ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
+      ScannerErrorCode.EXPECTED_TOKEN,
+      ParserErrorCode.EXPECTED_TOKEN
+    ], errors: [
+      expectedError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 28, 1),
+      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 32, 0),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 32, 0)
+    ]);
+  }
+
+  void test_useOfUnaryPlusOperator() {
+    createParser('+x');
+    Expression expression = parser.parseUnaryExpression();
+    expectNotNullIfNoErrors(expression);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 0, 1)]);
+    BinaryExpression binaryExpression = expression;
+    expect(binaryExpression.leftOperand.isSynthetic, isTrue);
+    expect(binaryExpression.rightOperand.isSynthetic, isFalse);
+    SimpleIdentifier identifier = binaryExpression.rightOperand;
+    expect(identifier.name, 'x');
+  }
+
+  void test_varAndType_field() {
+    parseCompilationUnit("class C { var int x; }",
+        errors: [expectedError(ParserErrorCode.VAR_AND_TYPE, 10, 3)]);
+  }
+
+  void test_varAndType_local() {
+    // This is currently reporting EXPECTED_TOKEN for a missing semicolon, but
+    // this would be a better error message.
+    parseStatement("var int x;");
+    listener.assertErrors([expectedError(ParserErrorCode.VAR_AND_TYPE, 0, 3)]);
+  }
+
+  void test_varAndType_parameter() {
+    // This is currently reporting EXPECTED_TOKEN for a missing semicolon, but
+    // this would be a better error message.
+    createParser('(var int x)');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    listener.assertErrors([expectedError(ParserErrorCode.VAR_AND_TYPE, 1, 3)]);
+  }
+
+  void test_varAndType_topLevelVariable() {
+    parseCompilationUnit("var int x;",
+        errors: [expectedError(ParserErrorCode.VAR_AND_TYPE, 0, 3)]);
+  }
+
+  void test_varAsTypeName_as() {
+    parseExpression("x as var",
+        expectedEndOffset: 5,
+        errors: [expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 5, 3)]);
+  }
+
+  void test_varClass() {
+    parseCompilationUnit("var class C {}", errors: [
+      // Fasta interprets the `var` as a malformed top level var
+      // and `class` as the start of a class declaration.
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 4, 5),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 4, 5),
+    ]);
+  }
+
+  void test_varEnum() {
+    parseCompilationUnit("var enum E {ONE}", errors: [
+      // Fasta interprets the `var` as a malformed top level var
+      // and `enum` as the start of an enum declaration.
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 4, 4),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 4, 4),
+    ]);
+  }
+
+  void test_varReturnType() {
+    createParser('var m() {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.VAR_RETURN_TYPE, 0, 3)]);
+  }
+
+  void test_varTypedef() {
+    parseCompilationUnit("var typedef F();", errors: [
+      // Fasta interprets the `var` as a malformed top level var
+      // and `typedef` as the start of an typedef declaration.
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 4, 7),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 4, 7),
+    ]);
+  }
+
+  void test_voidParameter() {
+    NormalFormalParameter parameter =
+        parseFormalParameterList('(void a)').parameters[0];
+    expectNotNullIfNoErrors(parameter);
+    assertNoErrors();
+  }
+
+  void test_voidVariable_parseClassMember_initializer() {
+    createParser('void x = 0;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    assertNoErrors();
+  }
+
+  void test_voidVariable_parseClassMember_noInitializer() {
+    createParser('void x;');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    assertNoErrors();
+  }
+
+  void test_voidVariable_parseCompilationUnit_initializer() {
+    parseCompilationUnit("void x = 0;");
+  }
+
+  void test_voidVariable_parseCompilationUnit_noInitializer() {
+    parseCompilationUnit("void x;");
+  }
+
+  void test_voidVariable_parseCompilationUnitMember_initializer() {
+    createParser('void a = 0;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expectNotNullIfNoErrors(member);
+    assertNoErrors();
+  }
+
+  void test_voidVariable_parseCompilationUnitMember_noInitializer() {
+    createParser('void a;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expectNotNullIfNoErrors(member);
+    assertNoErrors();
+  }
+
+  void test_voidVariable_statement_initializer() {
+    parseStatement("void x = 0;");
+    assertNoErrors();
+  }
+
+  void test_voidVariable_statement_noInitializer() {
+    parseStatement("void x;");
+    assertNoErrors();
+  }
+
+  void test_withBeforeExtends() {
+    parseCompilationUnit("class A with B extends C {}",
+        errors: [expectedError(ParserErrorCode.WITH_BEFORE_EXTENDS, 15, 7)]);
+  }
+
+  void test_withWithoutExtends() {
+    createParser('class A with B, C {}');
+    ClassDeclaration declaration = parseFullCompilationUnitMember();
+    expectNotNullIfNoErrors(declaration);
+    listener.assertNoErrors();
+  }
+
+  void test_wrongSeparatorForPositionalParameter() {
+    createParser('(a, [b : 0])');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    listener.assertErrors([
+      expectedError(
+          ParserErrorCode.WRONG_SEPARATOR_FOR_POSITIONAL_PARAMETER, 7, 1)
+    ]);
+  }
+
+  void test_wrongTerminatorForParameterGroup_named() {
+    createParser('(a, {b, c])');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    // fasta scanner generates '(a, {b, c]})' where '}' is synthetic
+    listener.assertErrors([
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 9, 1),
+      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 10, 1)
+    ]);
+  }
+
+  void test_wrongTerminatorForParameterGroup_optional() {
+    createParser('(a, [b, c})');
+    FormalParameterList list = parser.parseFormalParameterList();
+    expectNotNullIfNoErrors(list);
+    // fasta scanner generates '(a, [b, c}])' where ']' is synthetic
+    listener.assertErrors([
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 9, 1),
+      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 10, 1)
+    ]);
+  }
+
+  void test_yieldAsLabel() {
+    // yield can be used as a label
+    parseCompilationUnit('main() { yield: break yield; }');
+  }
+}
diff --git a/pkg/analyzer/test/generated/expression_parser_test.dart b/pkg/analyzer/test/generated/expression_parser_test.dart
new file mode 100644
index 0000000..567af1a
--- /dev/null
+++ b/pkg/analyzer/test/generated/expression_parser_test.dart
@@ -0,0 +1,2558 @@
+// Copyright (c) 2020, 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.
+
+import 'package:_fe_analyzer_shared/src/scanner/abstract_scanner.dart'
+    show AbstractScanner;
+import 'package:_fe_analyzer_shared/src/scanner/errors.dart';
+import 'package:analyzer/dart/analysis/features.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/src/dart/ast/ast.dart'
+    show InstanceCreationExpressionImpl;
+import 'package:analyzer/src/dart/scanner/scanner.dart';
+import 'package:analyzer/src/error/codes.dart';
+import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
+import 'package:analyzer/src/generated/testing/token_factory.dart';
+import 'package:pub_semver/src/version.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../util/ast_type_matchers.dart';
+import 'parser_test_base.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(ExpressionParserTest);
+  });
+}
+
+/// Tests of the fasta parser based on [ExpressionParserTestMixin].
+@reflectiveTest
+class ExpressionParserTest extends FastaParserTestCase {
+  final beforeUiAsCode = FeatureSet.fromEnableFlags2(
+    sdkLanguageVersion: Version.parse('2.2.0'),
+    flags: [],
+  );
+
+  void test_binaryExpression_allOperators() {
+    // https://github.com/dart-lang/sdk/issues/36255
+    for (TokenType type in TokenType.all) {
+      if (type.precedence > 0) {
+        var source = 'a ${type.lexeme} b';
+        try {
+          parseExpression(source);
+        } on TestFailure {
+          // Ensure that there are no infinite loops or exceptions thrown
+          // by the parser. Test failures are fine.
+        }
+      }
+    }
+  }
+
+  void test_invalidExpression_37706() {
+    // https://github.com/dart-lang/sdk/issues/37706
+    parseExpression('<b?c>()', errors: [
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 1, 1),
+      expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 7, 0),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 7, 0),
+    ]);
+  }
+
+  void test_listLiteral_invalid_assert() {
+    // https://github.com/dart-lang/sdk/issues/37674
+    parseExpression('n=<.["\$assert', errors: [
+      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 3, 1),
+      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 4, 1),
+      expectedError(ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD, 7, 6),
+      expectedError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 12, 1),
+      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 13, 1),
+    ]);
+  }
+
+  void test_listLiteral_invalidElement_37697() {
+    // https://github.com/dart-lang/sdk/issues/37674
+    parseExpression('[<y.<z>(){}]', errors: [
+      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 4, 1),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 6, 1),
+    ]);
+  }
+
+  void test_lt_dot_bracket_quote() {
+    // https://github.com/dart-lang/sdk/issues/37674
+    var list = parseExpression('<.["', errors: [
+      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 1, 1),
+      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 2, 1),
+      expectedError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 3, 1),
+      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 4, 1),
+    ]) as ListLiteral;
+    expect(list.elements, hasLength(1));
+    var first = list.elements[0] as StringLiteral;
+    expect(first.length, 1);
+  }
+
+  void test_lt_dot_listLiteral() {
+    // https://github.com/dart-lang/sdk/issues/37674
+    var list = parseExpression('<.[]', errors: [
+      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 1, 1),
+      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 2, 2),
+    ]) as ListLiteral;
+    expect(list.elements, hasLength(0));
+  }
+
+  void test_mapLiteral() {
+    var map = parseExpression('{3: 6}') as SetOrMapLiteral;
+    expect(map.constKeyword, isNull);
+    expect(map.typeArguments, isNull);
+    expect(map.elements, hasLength(1));
+    var entry = map.elements[0] as MapLiteralEntry;
+    var key = entry.key as IntegerLiteral;
+    expect(key.value, 3);
+    var value = entry.value as IntegerLiteral;
+    expect(value.value, 6);
+  }
+
+  void test_mapLiteral_const() {
+    var map = parseExpression('const {3: 6}') as SetOrMapLiteral;
+    expect(map.constKeyword, isNotNull);
+    expect(map.typeArguments, isNull);
+    expect(map.elements, hasLength(1));
+    var entry = map.elements[0] as MapLiteralEntry;
+    var key = entry.key as IntegerLiteral;
+    expect(key.value, 3);
+    var value = entry.value as IntegerLiteral;
+    expect(value.value, 6);
+  }
+
+  @failingTest
+  void test_mapLiteral_invalid_too_many_type_arguments1() {
+    var map = parseExpression('<int, int, int>{}', errors: [
+      // TODO(danrubel): Currently the resolver reports invalid number of
+      // type arguments, but the parser could report this.
+      expectedError(
+          /* ParserErrorCode.EXPECTED_ONE_OR_TWO_TYPE_VARIABLES */
+          ParserErrorCode.EXPECTED_TOKEN,
+          11,
+          3),
+    ]) as SetOrMapLiteral;
+    expect(map.constKeyword, isNull);
+    expect(map.elements, hasLength(0));
+  }
+
+  @failingTest
+  void test_mapLiteral_invalid_too_many_type_arguments2() {
+    var map = parseExpression('<int, int, int>{1}', errors: [
+      // TODO(danrubel): Currently the resolver reports invalid number of
+      // type arguments, but the parser could report this.
+      expectedError(
+          /* ParserErrorCode.EXPECTED_ONE_OR_TWO_TYPE_VARIABLES */
+          ParserErrorCode.EXPECTED_TOKEN,
+          11,
+          3),
+    ]) as SetOrMapLiteral;
+    expect(map.constKeyword, isNull);
+    expect(map.elements, hasLength(0));
+  }
+
+  void test_namedArgument() {
+    var invocation = parseExpression('m(a: 1, b: 2)') as MethodInvocation;
+    List<Expression> arguments = invocation.argumentList.arguments;
+
+    var a = arguments[0] as NamedExpression;
+    expect(a.name.label.name, 'a');
+    expect(a.expression, isNotNull);
+
+    var b = arguments[1] as NamedExpression;
+    expect(b.name.label.name, 'b');
+    expect(b.expression, isNotNull);
+  }
+
+  void test_parseAdditiveExpression_normal() {
+    Expression expression = parseAdditiveExpression('x + y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var binaryExpression = expression as BinaryExpression;
+    expect(binaryExpression.leftOperand, isNotNull);
+    expect(binaryExpression.operator, isNotNull);
+    expect(binaryExpression.operator.type, TokenType.PLUS);
+    expect(binaryExpression.rightOperand, isNotNull);
+  }
+
+  void test_parseAdditiveExpression_super() {
+    Expression expression = parseAdditiveExpression('super + y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var binaryExpression = expression as BinaryExpression;
+    expect(binaryExpression.leftOperand, isSuperExpression);
+    expect(binaryExpression.operator, isNotNull);
+    expect(binaryExpression.operator.type, TokenType.PLUS);
+    expect(binaryExpression.rightOperand, isNotNull);
+  }
+
+  void test_parseAssignableExpression_expression_args_dot() {
+    Expression expression = parseAssignableExpression('(x)(y).z', false);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var propertyAccess = expression as PropertyAccess;
+    FunctionExpressionInvocation invocation =
+        propertyAccess.target as FunctionExpressionInvocation;
+    expect(invocation.function, isNotNull);
+    expect(invocation.typeArguments, isNull);
+    ArgumentList argumentList = invocation.argumentList;
+    expect(argumentList, isNotNull);
+    expect(argumentList.arguments, hasLength(1));
+    expect(propertyAccess.operator, isNotNull);
+    expect(propertyAccess.propertyName, isNotNull);
+  }
+
+  void test_parseAssignableExpression_expression_args_dot_typeArguments() {
+    Expression expression = parseAssignableExpression('(x)<F>(y).z', false);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var propertyAccess = expression as PropertyAccess;
+    FunctionExpressionInvocation invocation =
+        propertyAccess.target as FunctionExpressionInvocation;
+    expect(invocation.function, isNotNull);
+    expect(invocation.typeArguments, isNotNull);
+    ArgumentList argumentList = invocation.argumentList;
+    expect(argumentList, isNotNull);
+    expect(argumentList.arguments, hasLength(1));
+    expect(propertyAccess.operator, isNotNull);
+    expect(propertyAccess.propertyName, isNotNull);
+  }
+
+  void test_parseAssignableExpression_expression_dot() {
+    Expression expression = parseAssignableExpression('(x).y', false);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var propertyAccess = expression as PropertyAccess;
+    expect(propertyAccess.target, isNotNull);
+    expect(propertyAccess.operator.type, TokenType.PERIOD);
+    expect(propertyAccess.propertyName, isNotNull);
+  }
+
+  void test_parseAssignableExpression_expression_index() {
+    Expression expression = parseAssignableExpression('(x)[y]', false);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var indexExpression = expression as IndexExpression;
+    expect(indexExpression.target, isNotNull);
+    expect(indexExpression.leftBracket, isNotNull);
+    expect(indexExpression.index, isNotNull);
+    expect(indexExpression.rightBracket, isNotNull);
+  }
+
+  void test_parseAssignableExpression_expression_question_dot() {
+    Expression expression = parseAssignableExpression('(x)?.y', false);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var propertyAccess = expression as PropertyAccess;
+    expect(propertyAccess.target, isNotNull);
+    expect(propertyAccess.operator.type, TokenType.QUESTION_PERIOD);
+    expect(propertyAccess.propertyName, isNotNull);
+  }
+
+  void test_parseAssignableExpression_identifier() {
+    Expression expression = parseAssignableExpression('x', false);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var identifier = expression as SimpleIdentifier;
+    expect(identifier, isNotNull);
+  }
+
+  void test_parseAssignableExpression_identifier_args_dot() {
+    Expression expression = parseAssignableExpression('x(y).z', false);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var propertyAccess = expression as PropertyAccess;
+    MethodInvocation invocation = propertyAccess.target as MethodInvocation;
+    expect(invocation.methodName.name, "x");
+    expect(invocation.typeArguments, isNull);
+    ArgumentList argumentList = invocation.argumentList;
+    expect(argumentList, isNotNull);
+    expect(argumentList.arguments, hasLength(1));
+    expect(propertyAccess.operator, isNotNull);
+    expect(propertyAccess.propertyName, isNotNull);
+  }
+
+  void test_parseAssignableExpression_identifier_args_dot_typeArguments() {
+    Expression expression = parseAssignableExpression('x<E>(y).z', false);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var propertyAccess = expression as PropertyAccess;
+    MethodInvocation invocation = propertyAccess.target as MethodInvocation;
+    expect(invocation.methodName.name, "x");
+    expect(invocation.typeArguments, isNotNull);
+    ArgumentList argumentList = invocation.argumentList;
+    expect(argumentList, isNotNull);
+    expect(argumentList.arguments, hasLength(1));
+    expect(propertyAccess.operator, isNotNull);
+    expect(propertyAccess.propertyName, isNotNull);
+  }
+
+  void test_parseAssignableExpression_identifier_dot() {
+    Expression expression = parseAssignableExpression('x.y', false);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var identifier = expression as PrefixedIdentifier;
+    expect(identifier.prefix.name, 'x');
+    expect(identifier.period, isNotNull);
+    expect(identifier.period.type, TokenType.PERIOD);
+    expect(identifier.identifier.name, 'y');
+  }
+
+  void test_parseAssignableExpression_identifier_index() {
+    Expression expression = parseAssignableExpression('x[y]', false);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var indexExpression = expression as IndexExpression;
+    expect(indexExpression.target, isNotNull);
+    expect(indexExpression.leftBracket, isNotNull);
+    expect(indexExpression.index, isNotNull);
+    expect(indexExpression.rightBracket, isNotNull);
+  }
+
+  void test_parseAssignableExpression_identifier_question_dot() {
+    Expression expression = parseAssignableExpression('x?.y', false);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var propertyAccess = expression as PropertyAccess;
+    expect(propertyAccess.target, isNotNull);
+    expect(propertyAccess.operator.type, TokenType.QUESTION_PERIOD);
+    expect(propertyAccess.propertyName, isNotNull);
+  }
+
+  void test_parseAssignableExpression_super_dot() {
+    Expression expression = parseAssignableExpression('super.y', false);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var propertyAccess = expression as PropertyAccess;
+    expect(propertyAccess.target, isSuperExpression);
+    expect(propertyAccess.operator, isNotNull);
+    expect(propertyAccess.propertyName, isNotNull);
+  }
+
+  void test_parseAssignableExpression_super_index() {
+    Expression expression = parseAssignableExpression('super[y]', false);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var indexExpression = expression as IndexExpression;
+    expect(indexExpression.target, isSuperExpression);
+    expect(indexExpression.leftBracket, isNotNull);
+    expect(indexExpression.index, isNotNull);
+    expect(indexExpression.rightBracket, isNotNull);
+  }
+
+  void test_parseAssignableSelector_dot() {
+    Expression expression = parseAssignableSelector('.x', true);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var propertyAccess = expression as PropertyAccess;
+    expect(propertyAccess.operator.type, TokenType.PERIOD);
+    expect(propertyAccess.propertyName, isNotNull);
+  }
+
+  void test_parseAssignableSelector_index() {
+    Expression expression = parseAssignableSelector('[x]', true);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var indexExpression = expression as IndexExpression;
+    expect(indexExpression.leftBracket, isNotNull);
+    expect(indexExpression.index, isNotNull);
+    expect(indexExpression.rightBracket, isNotNull);
+  }
+
+  void test_parseAssignableSelector_none() {
+    Expression expression = parseAssignableSelector('', true);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var identifier = expression as SimpleIdentifier;
+    expect(identifier, isNotNull);
+  }
+
+  void test_parseAssignableSelector_question_dot() {
+    Expression expression = parseAssignableSelector('?.x', true);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var propertyAccess = expression as PropertyAccess;
+    expect(propertyAccess.operator.type, TokenType.QUESTION_PERIOD);
+    expect(propertyAccess.propertyName, isNotNull);
+  }
+
+  void test_parseAwaitExpression() {
+    AwaitExpression expression = parseAwaitExpression('await x');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.awaitKeyword, isNotNull);
+    expect(expression.expression, isNotNull);
+  }
+
+  void test_parseBitwiseAndExpression_normal() {
+    Expression expression = parseBitwiseAndExpression('x & y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var binaryExpression = expression as BinaryExpression;
+    expect(binaryExpression.leftOperand, isNotNull);
+    expect(binaryExpression.operator, isNotNull);
+    expect(binaryExpression.operator.type, TokenType.AMPERSAND);
+    expect(binaryExpression.rightOperand, isNotNull);
+  }
+
+  void test_parseBitwiseAndExpression_super() {
+    Expression expression = parseBitwiseAndExpression('super & y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var binaryExpression = expression as BinaryExpression;
+    expect(binaryExpression.leftOperand, isSuperExpression);
+    expect(binaryExpression.operator, isNotNull);
+    expect(binaryExpression.operator.type, TokenType.AMPERSAND);
+    expect(binaryExpression.rightOperand, isNotNull);
+  }
+
+  void test_parseBitwiseOrExpression_normal() {
+    Expression expression = parseBitwiseOrExpression('x | y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var binaryExpression = expression as BinaryExpression;
+    expect(binaryExpression.leftOperand, isNotNull);
+    expect(binaryExpression.operator, isNotNull);
+    expect(binaryExpression.operator.type, TokenType.BAR);
+    expect(binaryExpression.rightOperand, isNotNull);
+  }
+
+  void test_parseBitwiseOrExpression_super() {
+    Expression expression = parseBitwiseOrExpression('super | y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var binaryExpression = expression as BinaryExpression;
+    expect(binaryExpression.leftOperand, isSuperExpression);
+    expect(binaryExpression.operator, isNotNull);
+    expect(binaryExpression.operator.type, TokenType.BAR);
+    expect(binaryExpression.rightOperand, isNotNull);
+  }
+
+  void test_parseBitwiseXorExpression_normal() {
+    Expression expression = parseBitwiseXorExpression('x ^ y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var binaryExpression = expression as BinaryExpression;
+    expect(binaryExpression.leftOperand, isNotNull);
+    expect(binaryExpression.operator, isNotNull);
+    expect(binaryExpression.operator.type, TokenType.CARET);
+    expect(binaryExpression.rightOperand, isNotNull);
+  }
+
+  void test_parseBitwiseXorExpression_super() {
+    Expression expression = parseBitwiseXorExpression('super ^ y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var binaryExpression = expression as BinaryExpression;
+    expect(binaryExpression.leftOperand, isSuperExpression);
+    expect(binaryExpression.operator, isNotNull);
+    expect(binaryExpression.operator.type, TokenType.CARET);
+    expect(binaryExpression.rightOperand, isNotNull);
+  }
+
+  void test_parseCascadeSection_i() {
+    Expression expression = parseCascadeSection('..[i]');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var section = expression as IndexExpression;
+    expect(section.target, isNull);
+    expect(section.leftBracket, isNotNull);
+    expect(section.index, isNotNull);
+    expect(section.rightBracket, isNotNull);
+  }
+
+  void test_parseCascadeSection_ia() {
+    Expression expression = parseCascadeSection('..[i](b)');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var section = expression as FunctionExpressionInvocation;
+    expect(section.function, isIndexExpression);
+    expect(section.typeArguments, isNull);
+    expect(section.argumentList, isNotNull);
+  }
+
+  void test_parseCascadeSection_ia_typeArguments() {
+    Expression expression = parseCascadeSection('..[i]<E>(b)');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var section = expression as FunctionExpressionInvocation;
+    expect(section.function, isIndexExpression);
+    expect(section.typeArguments, isNotNull);
+    expect(section.argumentList, isNotNull);
+  }
+
+  void test_parseCascadeSection_ii() {
+    Expression expression = parseCascadeSection('..a(b).c(d)');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var section = expression as MethodInvocation;
+    expect(section.target, isMethodInvocation);
+    expect(section.operator, isNotNull);
+    expect(section.methodName, isNotNull);
+    expect(section.typeArguments, isNull);
+    expect(section.argumentList, isNotNull);
+    expect(section.argumentList.arguments, hasLength(1));
+  }
+
+  void test_parseCascadeSection_ii_typeArguments() {
+    Expression expression = parseCascadeSection('..a<E>(b).c<F>(d)');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var section = expression as MethodInvocation;
+    expect(section.target, isMethodInvocation);
+    expect(section.operator, isNotNull);
+    expect(section.methodName, isNotNull);
+    expect(section.typeArguments, isNotNull);
+    expect(section.argumentList, isNotNull);
+    expect(section.argumentList.arguments, hasLength(1));
+  }
+
+  void test_parseCascadeSection_p() {
+    Expression expression = parseCascadeSection('..a');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var section = expression as PropertyAccess;
+    expect(section.target, isNull);
+    expect(section.operator, isNotNull);
+    expect(section.propertyName, isNotNull);
+  }
+
+  void test_parseCascadeSection_p_assign() {
+    Expression expression = parseCascadeSection('..a = 3');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var section = expression as AssignmentExpression;
+    expect(section.leftHandSide, isNotNull);
+    expect(section.operator, isNotNull);
+    Expression rhs = section.rightHandSide;
+    expect(rhs, isNotNull);
+  }
+
+  void test_parseCascadeSection_p_assign_withCascade() {
+    Expression expression = parseCascadeSection('..a = 3..m()');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var section = expression as AssignmentExpression;
+    expect(section.leftHandSide, isNotNull);
+    expect(section.operator, isNotNull);
+    Expression rhs = section.rightHandSide;
+    expect(rhs, isIntegerLiteral);
+  }
+
+  void test_parseCascadeSection_p_assign_withCascade_typeArguments() {
+    Expression expression = parseCascadeSection('..a = 3..m<E>()');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var section = expression as AssignmentExpression;
+    expect(section.leftHandSide, isNotNull);
+    expect(section.operator, isNotNull);
+    Expression rhs = section.rightHandSide;
+    expect(rhs, isIntegerLiteral);
+  }
+
+  void test_parseCascadeSection_p_builtIn() {
+    Expression expression = parseCascadeSection('..as');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var section = expression as PropertyAccess;
+    expect(section.target, isNull);
+    expect(section.operator, isNotNull);
+    expect(section.propertyName, isNotNull);
+  }
+
+  void test_parseCascadeSection_pa() {
+    Expression expression = parseCascadeSection('..a(b)');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var section = expression as MethodInvocation;
+    expect(section.target, isNull);
+    expect(section.operator, isNotNull);
+    expect(section.methodName, isNotNull);
+    expect(section.typeArguments, isNull);
+    expect(section.argumentList, isNotNull);
+    expect(section.argumentList.arguments, hasLength(1));
+  }
+
+  void test_parseCascadeSection_pa_typeArguments() {
+    Expression expression = parseCascadeSection('..a<E>(b)');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var section = expression as MethodInvocation;
+    expect(section.target, isNull);
+    expect(section.operator, isNotNull);
+    expect(section.methodName, isNotNull);
+    expect(section.typeArguments, isNotNull);
+    expect(section.argumentList, isNotNull);
+    expect(section.argumentList.arguments, hasLength(1));
+  }
+
+  void test_parseCascadeSection_paa() {
+    Expression expression = parseCascadeSection('..a(b)(c)');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var section = expression as FunctionExpressionInvocation;
+    expect(section.function, isMethodInvocation);
+    expect(section.typeArguments, isNull);
+    expect(section.argumentList, isNotNull);
+    expect(section.argumentList.arguments, hasLength(1));
+  }
+
+  void test_parseCascadeSection_paa_typeArguments() {
+    Expression expression = parseCascadeSection('..a<E>(b)<F>(c)');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var section = expression as FunctionExpressionInvocation;
+    expect(section.function, isMethodInvocation);
+    expect(section.typeArguments, isNotNull);
+    expect(section.argumentList, isNotNull);
+    expect(section.argumentList.arguments, hasLength(1));
+  }
+
+  void test_parseCascadeSection_paapaa() {
+    Expression expression = parseCascadeSection('..a(b)(c).d(e)(f)');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var section = expression as FunctionExpressionInvocation;
+    expect(section.function, isMethodInvocation);
+    expect(section.typeArguments, isNull);
+    expect(section.argumentList, isNotNull);
+    expect(section.argumentList.arguments, hasLength(1));
+  }
+
+  void test_parseCascadeSection_paapaa_typeArguments() {
+    Expression expression =
+        parseCascadeSection('..a<E>(b)<F>(c).d<G>(e)<H>(f)');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var section = expression as FunctionExpressionInvocation;
+    expect(section.function, isMethodInvocation);
+    expect(section.typeArguments, isNotNull);
+    expect(section.argumentList, isNotNull);
+    expect(section.argumentList.arguments, hasLength(1));
+  }
+
+  void test_parseCascadeSection_pap() {
+    Expression expression = parseCascadeSection('..a(b).c');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var section = expression as PropertyAccess;
+    expect(section.target, isNotNull);
+    expect(section.operator, isNotNull);
+    expect(section.propertyName, isNotNull);
+  }
+
+  void test_parseCascadeSection_pap_typeArguments() {
+    Expression expression = parseCascadeSection('..a<E>(b).c');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var section = expression as PropertyAccess;
+    expect(section.target, isNotNull);
+    expect(section.operator, isNotNull);
+    expect(section.propertyName, isNotNull);
+  }
+
+  void test_parseConditionalExpression() {
+    ConditionalExpression expression = parseConditionalExpression('x ? y : z');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.condition, isNotNull);
+    expect(expression.question, isNotNull);
+    expect(expression.thenExpression, isNotNull);
+    expect(expression.colon, isNotNull);
+    expect(expression.elseExpression, isNotNull);
+  }
+
+  void test_parseConstExpression_instanceCreation() {
+    Expression expression = parseConstExpression('const A()');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression, isInstanceCreationExpression);
+    InstanceCreationExpression instanceCreation = expression;
+    expect(instanceCreation.keyword, isNotNull);
+    ConstructorName name = instanceCreation.constructorName;
+    expect(name, isNotNull);
+    expect(name.type, isNotNull);
+    expect(name.period, isNull);
+    expect(name.name, isNull);
+    expect(instanceCreation.argumentList, isNotNull);
+  }
+
+  void test_parseConstExpression_listLiteral_typed() {
+    Expression expression = parseConstExpression('const <A> []');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as ListLiteral;
+    expect(literal.constKeyword, isNotNull);
+    expect(literal.typeArguments, isNotNull);
+    expect(literal.leftBracket, isNotNull);
+    expect(literal.elements, hasLength(0));
+    expect(literal.rightBracket, isNotNull);
+  }
+
+  void test_parseConstExpression_listLiteral_untyped() {
+    Expression expression = parseConstExpression('const []');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as ListLiteral;
+    expect(literal.constKeyword, isNotNull);
+    expect(literal.typeArguments, isNull);
+    expect(literal.leftBracket, isNotNull);
+    expect(literal.elements, hasLength(0));
+    expect(literal.rightBracket, isNotNull);
+  }
+
+  void test_parseConstExpression_mapLiteral_typed() {
+    Expression expression = parseConstExpression('const <A, B> {}');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as SetOrMapLiteral;
+    expect(literal.leftBracket, isNotNull);
+    expect(literal.elements, hasLength(0));
+    expect(literal.rightBracket, isNotNull);
+    expect(literal.typeArguments, isNotNull);
+  }
+
+  void test_parseConstExpression_mapLiteral_typed_missingGt() {
+    Expression expression = parseExpression('const <A, B {}',
+        errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 10, 1)]);
+    expect(expression, isNotNull);
+    var literal = expression as SetOrMapLiteral;
+    expect(literal.leftBracket, isNotNull);
+    expect(literal.elements, hasLength(0));
+    expect(literal.rightBracket, isNotNull);
+    expect(literal.typeArguments, isNotNull);
+  }
+
+  void test_parseConstExpression_mapLiteral_untyped() {
+    Expression expression = parseConstExpression('const {}');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as SetOrMapLiteral;
+    expect(literal.leftBracket, isNotNull);
+    expect(literal.elements, hasLength(0));
+    expect(literal.rightBracket, isNotNull);
+    expect(literal.typeArguments, isNull);
+  }
+
+  void test_parseConstructorInitializer_functionExpression() {
+    // https://github.com/dart-lang/sdk/issues/37414
+    parseCompilationUnit('class C { C.n() : this()(); }', errors: [
+      expectedError(ParserErrorCode.INVALID_INITIALIZER, 18, 8),
+    ]);
+  }
+
+  void test_parseEqualityExpression_normal() {
+    BinaryExpression expression = parseEqualityExpression('x == y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.leftOperand, isNotNull);
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.EQ_EQ);
+    expect(expression.rightOperand, isNotNull);
+  }
+
+  void test_parseEqualityExpression_super() {
+    BinaryExpression expression = parseEqualityExpression('super == y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.leftOperand, isSuperExpression);
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.EQ_EQ);
+    expect(expression.rightOperand, isNotNull);
+  }
+
+  void test_parseExpression_assign() {
+    // TODO(brianwilkerson) Implement more tests for this method.
+    Expression expression = parseExpression('x = y');
+    var assignmentExpression = expression as AssignmentExpression;
+    expect(assignmentExpression.leftHandSide, isNotNull);
+    expect(assignmentExpression.operator, isNotNull);
+    expect(assignmentExpression.operator.type, TokenType.EQ);
+    expect(assignmentExpression.rightHandSide, isNotNull);
+  }
+
+  void test_parseExpression_assign_compound() {
+    if (AbstractScanner.LAZY_ASSIGNMENT_ENABLED) {
+      Expression expression = parseExpression('x ||= y');
+      var assignmentExpression = expression as AssignmentExpression;
+      expect(assignmentExpression.leftHandSide, isNotNull);
+      expect(assignmentExpression.operator, isNotNull);
+      expect(assignmentExpression.operator.type, TokenType.BAR_BAR_EQ);
+      expect(assignmentExpression.rightHandSide, isNotNull);
+    }
+  }
+
+  void test_parseExpression_comparison() {
+    Expression expression = parseExpression('--a.b == c');
+    var binaryExpression = expression as BinaryExpression;
+    expect(binaryExpression.leftOperand, isNotNull);
+    expect(binaryExpression.operator, isNotNull);
+    expect(binaryExpression.operator.type, TokenType.EQ_EQ);
+    expect(binaryExpression.rightOperand, isNotNull);
+  }
+
+  void test_parseExpression_constAndTypeParameters() {
+    Expression expression = parseExpression('const <E>', codes: [
+      // TODO(danrubel): Improve this error message.
+      ParserErrorCode.EXPECTED_TOKEN
+    ]);
+    expect(expression, isNotNull);
+  }
+
+  void test_parseExpression_function_async() {
+    Expression expression = parseExpression('() async {}');
+    var functionExpression = expression as FunctionExpression;
+    expect(functionExpression.body, isNotNull);
+    expect(functionExpression.body.isAsynchronous, isTrue);
+    expect(functionExpression.body.isGenerator, isFalse);
+    expect(functionExpression.parameters, isNotNull);
+  }
+
+  void test_parseExpression_function_asyncStar() {
+    Expression expression = parseExpression('() async* {}');
+    var functionExpression = expression as FunctionExpression;
+    expect(functionExpression.body, isNotNull);
+    expect(functionExpression.body.isAsynchronous, isTrue);
+    expect(functionExpression.body.isGenerator, isTrue);
+    expect(functionExpression.parameters, isNotNull);
+  }
+
+  void test_parseExpression_function_sync() {
+    Expression expression = parseExpression('() {}');
+    var functionExpression = expression as FunctionExpression;
+    expect(functionExpression.body, isNotNull);
+    expect(functionExpression.body.isAsynchronous, isFalse);
+    expect(functionExpression.body.isGenerator, isFalse);
+    expect(functionExpression.parameters, isNotNull);
+  }
+
+  void test_parseExpression_function_syncStar() {
+    Expression expression = parseExpression('() sync* {}');
+    var functionExpression = expression as FunctionExpression;
+    expect(functionExpression.body, isNotNull);
+    expect(functionExpression.body.isAsynchronous, isFalse);
+    expect(functionExpression.body.isGenerator, isTrue);
+    expect(functionExpression.parameters, isNotNull);
+  }
+
+  void test_parseExpression_invokeFunctionExpression() {
+    Expression expression = parseExpression('(a) {return a + a;} (3)');
+    var invocation = expression as FunctionExpressionInvocation;
+    expect(invocation.function, isFunctionExpression);
+    FunctionExpression functionExpression =
+        invocation.function as FunctionExpression;
+    expect(functionExpression.parameters, isNotNull);
+    expect(functionExpression.body, isNotNull);
+    expect(invocation.typeArguments, isNull);
+    ArgumentList list = invocation.argumentList;
+    expect(list, isNotNull);
+    expect(list.arguments, hasLength(1));
+  }
+
+  void test_parseExpression_nonAwait() {
+    Expression expression = parseExpression('await()');
+    var invocation = expression as MethodInvocation;
+    expect(invocation.methodName.name, 'await');
+    expect(invocation.typeArguments, isNull);
+    expect(invocation.argumentList, isNotNull);
+  }
+
+  void test_parseExpression_sendWithTypeParam_afterIndex() {
+    final unit = parseCompilationUnit('main() { factories[C]<num, int>(); }');
+    expect(unit.declarations, hasLength(1));
+    FunctionDeclaration mainMethod = unit.declarations[0];
+    BlockFunctionBody body = mainMethod.functionExpression.body;
+    NodeList<Statement> statements = body.block.statements;
+    expect(statements, hasLength(1));
+    ExpressionStatement statement = statements[0];
+    FunctionExpressionInvocation expression = statement.expression;
+
+    IndexExpression function = expression.function;
+    SimpleIdentifier target = function.target;
+    expect(target.name, 'factories');
+    SimpleIdentifier index = function.index;
+    expect(index.name, 'C');
+
+    NodeList<TypeAnnotation> typeArguments = expression.typeArguments.arguments;
+    expect(typeArguments, hasLength(2));
+    expect((typeArguments[0] as NamedType).name.name, 'num');
+    expect((typeArguments[1] as NamedType).name.name, 'int');
+
+    expect(expression.argumentList.arguments, hasLength(0));
+  }
+
+  void test_parseExpression_sendWithTypeParam_afterSend() {
+    final unit = parseCompilationUnit('main() { factories(C)<num, int>(); }');
+    expect(unit.declarations, hasLength(1));
+    FunctionDeclaration mainMethod = unit.declarations[0];
+    BlockFunctionBody body = mainMethod.functionExpression.body;
+    NodeList<Statement> statements = body.block.statements;
+    expect(statements, hasLength(1));
+    ExpressionStatement statement = statements[0];
+    FunctionExpressionInvocation expression = statement.expression;
+
+    MethodInvocation invocation = expression.function;
+    expect(invocation.methodName.name, 'factories');
+    NodeList<Expression> invocationArguments =
+        invocation.argumentList.arguments;
+    expect(invocationArguments, hasLength(1));
+    SimpleIdentifier index = invocationArguments[0];
+    expect(index.name, 'C');
+
+    NodeList<TypeAnnotation> typeArguments = expression.typeArguments.arguments;
+    expect(typeArguments, hasLength(2));
+    expect((typeArguments[0] as NamedType).name.name, 'num');
+    expect((typeArguments[1] as NamedType).name.name, 'int');
+
+    expect(expression.argumentList.arguments, hasLength(0));
+  }
+
+  void test_parseExpression_superMethodInvocation() {
+    Expression expression = parseExpression('super.m()');
+    var invocation = expression as MethodInvocation;
+    expect(invocation.target, isNotNull);
+    expect(invocation.methodName, isNotNull);
+    expect(invocation.typeArguments, isNull);
+    expect(invocation.argumentList, isNotNull);
+  }
+
+  void test_parseExpression_superMethodInvocation_typeArguments() {
+    Expression expression = parseExpression('super.m<E>()');
+    var invocation = expression as MethodInvocation;
+    expect(invocation.target, isNotNull);
+    expect(invocation.methodName, isNotNull);
+    expect(invocation.typeArguments, isNotNull);
+    expect(invocation.argumentList, isNotNull);
+  }
+
+  void test_parseExpression_superMethodInvocation_typeArguments_chained() {
+    Expression expression = parseExpression('super.b.c<D>()');
+    MethodInvocation invocation = expression as MethodInvocation;
+    Expression target = invocation.target;
+    expect(target, isPropertyAccess);
+    expect(invocation.methodName, isNotNull);
+    expect(invocation.methodName.name, 'c');
+    expect(invocation.typeArguments, isNotNull);
+    expect(invocation.argumentList, isNotNull);
+  }
+
+  void test_parseExpressionList_multiple() {
+    List<Expression> result = parseExpressionList('1, 2, 3');
+    expect(result, isNotNull);
+    assertNoErrors();
+    expect(result, hasLength(3));
+  }
+
+  void test_parseExpressionList_single() {
+    List<Expression> result = parseExpressionList('1');
+    expect(result, isNotNull);
+    assertNoErrors();
+    expect(result, hasLength(1));
+  }
+
+  void test_parseExpressionWithoutCascade_assign() {
+    // TODO(brianwilkerson) Implement more tests for this method.
+    Expression expression = parseExpressionWithoutCascade('x = y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var assignmentExpression = expression as AssignmentExpression;
+    expect(assignmentExpression.leftHandSide, isNotNull);
+    expect(assignmentExpression.operator, isNotNull);
+    expect(assignmentExpression.operator.type, TokenType.EQ);
+    expect(assignmentExpression.rightHandSide, isNotNull);
+  }
+
+  void test_parseExpressionWithoutCascade_comparison() {
+    Expression expression = parseExpressionWithoutCascade('--a.b == c');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var binaryExpression = expression as BinaryExpression;
+    expect(binaryExpression.leftOperand, isNotNull);
+    expect(binaryExpression.operator, isNotNull);
+    expect(binaryExpression.operator.type, TokenType.EQ_EQ);
+    expect(binaryExpression.rightOperand, isNotNull);
+  }
+
+  void test_parseExpressionWithoutCascade_superMethodInvocation() {
+    Expression expression = parseExpressionWithoutCascade('super.m()');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var invocation = expression as MethodInvocation;
+    expect(invocation.target, isNotNull);
+    expect(invocation.methodName, isNotNull);
+    expect(invocation.typeArguments, isNull);
+    expect(invocation.argumentList, isNotNull);
+  }
+
+  void
+      test_parseExpressionWithoutCascade_superMethodInvocation_typeArguments() {
+    Expression expression = parseExpressionWithoutCascade('super.m<E>()');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var invocation = expression as MethodInvocation;
+    expect(invocation.target, isNotNull);
+    expect(invocation.methodName, isNotNull);
+    expect(invocation.typeArguments, isNotNull);
+    expect(invocation.argumentList, isNotNull);
+  }
+
+  void test_parseFunctionExpression_body_inExpression() {
+    FunctionExpression expression = parseFunctionExpression('(int i) => i++');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.body, isNotNull);
+    expect(expression.typeParameters, isNull);
+    expect(expression.parameters, isNotNull);
+    expect((expression.body as ExpressionFunctionBody).semicolon, isNull);
+  }
+
+  void test_parseFunctionExpression_constAndTypeParameters2() {
+    FunctionExpression expression =
+        parseFunctionExpression('const <E>(E i) => i++');
+    expect(expression, isNotNull);
+    assertErrorsWithCodes([ParserErrorCode.UNEXPECTED_TOKEN]);
+    expect(expression.body, isNotNull);
+    expect(expression.typeParameters, isNotNull);
+    expect(expression.parameters, isNotNull);
+    expect((expression.body as ExpressionFunctionBody).semicolon, isNull);
+  }
+
+  void test_parseFunctionExpression_functionInPlaceOfTypeName() {
+    Expression expression = parseExpression('<test(' ', (){});>[0, 1, 2]',
+        codes: [ParserErrorCode.EXPECTED_TOKEN]);
+    expect(expression, isNotNull);
+    ListLiteral literal = expression;
+    expect(literal.typeArguments.arguments, hasLength(1));
+  }
+
+  void test_parseFunctionExpression_typeParameters() {
+    FunctionExpression expression = parseFunctionExpression('<E>(E i) => i++');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.body, isNotNull);
+    expect(expression.typeParameters, isNotNull);
+    expect(expression.parameters, isNotNull);
+    expect((expression.body as ExpressionFunctionBody).semicolon, isNull);
+  }
+
+  void test_parseInstanceCreationExpression_qualifiedType() {
+    Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
+    InstanceCreationExpression expression =
+        parseInstanceCreationExpression('A.B()', token);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.keyword.keyword, Keyword.NEW);
+    ConstructorName name = expression.constructorName;
+    expect(name, isNotNull);
+    TypeName type = name.type;
+    expect(type.name.name, 'A.B');
+    expect(type.typeArguments, isNull);
+    expect(name.period, isNull);
+    expect(name.name, isNull);
+    expect(expression.argumentList, isNotNull);
+  }
+
+  void test_parseInstanceCreationExpression_qualifiedType_named() {
+    Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
+    InstanceCreationExpression expression =
+        parseInstanceCreationExpression('A.B.c()', token);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.keyword.keyword, Keyword.NEW);
+    ConstructorName name = expression.constructorName;
+    expect(name, isNotNull);
+    TypeName type = name.type;
+    expect(type, isNotNull);
+    expect(type.typeArguments, isNull);
+    expect(name.period, isNotNull);
+    expect(name.name, isNotNull);
+    expect(expression.argumentList, isNotNull);
+  }
+
+  void
+      test_parseInstanceCreationExpression_qualifiedType_named_typeArguments() {
+    Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
+    InstanceCreationExpression expression =
+        parseInstanceCreationExpression('A.B<E>.c()', token);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.keyword.keyword, Keyword.NEW);
+    ConstructorName name = expression.constructorName;
+    expect(name, isNotNull);
+    TypeName type = name.type;
+    expect(type, isNotNull);
+    expect(type.typeArguments.arguments, hasLength(1));
+    expect(name.period, isNotNull);
+    expect(name.name, isNotNull);
+    expect(expression.argumentList, isNotNull);
+  }
+
+  void test_parseInstanceCreationExpression_qualifiedType_typeArguments() {
+    Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
+    InstanceCreationExpression expression =
+        parseInstanceCreationExpression('A.B<E>()', token);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.keyword.keyword, Keyword.NEW);
+    ConstructorName name = expression.constructorName;
+    expect(name, isNotNull);
+    TypeName type = name.type;
+    expect(type, isNotNull);
+    expect(type.typeArguments.arguments, hasLength(1));
+    expect(name.period, isNull);
+    expect(name.name, isNull);
+    expect(expression.argumentList, isNotNull);
+  }
+
+  void test_parseInstanceCreationExpression_type() {
+    Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
+    InstanceCreationExpression expression =
+        parseInstanceCreationExpression('A()', token);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.keyword.keyword, Keyword.NEW);
+    ConstructorName name = expression.constructorName;
+    expect(name, isNotNull);
+    TypeName type = name.type;
+    expect(type, isNotNull);
+    expect(type.typeArguments, isNull);
+    expect(name.period, isNull);
+    expect(name.name, isNull);
+    expect(expression.argumentList, isNotNull);
+  }
+
+  void test_parseInstanceCreationExpression_type_named() {
+    Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
+    InstanceCreationExpression expression =
+        parseInstanceCreationExpression('A.c()', token);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.keyword.keyword, Keyword.NEW);
+    ConstructorName name = expression.constructorName;
+    expect(name, isNotNull);
+    TypeName type = name.type;
+    expect(type, isNotNull);
+    expect(type.typeArguments, isNull);
+    expect(name.period, isNull);
+    expect(name.name, isNull);
+    expect(expression.argumentList, isNotNull);
+  }
+
+  void test_parseInstanceCreationExpression_type_named_typeArguments() {
+    Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
+    InstanceCreationExpressionImpl expression =
+        parseInstanceCreationExpression('A<B>.c()', token);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.keyword.keyword, Keyword.NEW);
+    ConstructorName name = expression.constructorName;
+    expect(name, isNotNull);
+    TypeName type = name.type;
+    expect(type, isNotNull);
+    expect(type.typeArguments.arguments, hasLength(1));
+    expect(name.period, isNotNull);
+    expect(name.name, isNotNull);
+    expect(expression.argumentList, isNotNull);
+    expect(expression.typeArguments, isNull);
+  }
+
+  void test_parseInstanceCreationExpression_type_named_typeArguments_34403() {
+    InstanceCreationExpressionImpl expression =
+        parseExpression('new a.b.c<C>()', errors: [
+      expectedError(
+          CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_CONSTRUCTOR, 8, 1)
+    ]);
+    expect(expression, isNotNull);
+    expect(expression.keyword.keyword, Keyword.NEW);
+    ConstructorName name = expression.constructorName;
+    expect(name, isNotNull);
+    TypeName type = name.type;
+    expect(type, isNotNull);
+    expect(type.typeArguments, isNull);
+    expect(name.period, isNotNull);
+    expect(name.name, isNotNull);
+    expect(expression.argumentList, isNotNull);
+    expect(expression.typeArguments.arguments, hasLength(1));
+  }
+
+  void test_parseInstanceCreationExpression_type_typeArguments() {
+    Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
+    InstanceCreationExpression expression =
+        parseInstanceCreationExpression('A<B>()', token);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.keyword.keyword, Keyword.NEW);
+    ConstructorName name = expression.constructorName;
+    expect(name, isNotNull);
+    TypeName type = name.type;
+    expect(type, isNotNull);
+    expect(type.typeArguments.arguments, hasLength(1));
+    expect(name.period, isNull);
+    expect(name.name, isNull);
+    expect(expression.argumentList, isNotNull);
+  }
+
+  void test_parseListLiteral_empty_oneToken() {
+    Token token = TokenFactory.tokenFromKeyword(Keyword.CONST);
+    ListLiteral literal = parseListLiteral(token, null, '[]');
+    expect(literal, isNotNull);
+    assertNoErrors();
+    expect(literal.constKeyword.keyword, Keyword.CONST);
+    expect(literal.typeArguments, isNull);
+    expect(literal.leftBracket, isNotNull);
+    expect(literal.elements, hasLength(0));
+    expect(literal.rightBracket, isNotNull);
+  }
+
+  void test_parseListLiteral_empty_oneToken_withComment() {
+    ListLiteral literal = parseListLiteral(null, null, '/* 0 */ []');
+    expect(literal, isNotNull);
+    assertNoErrors();
+    expect(literal.constKeyword, isNull);
+    expect(literal.typeArguments, isNull);
+    Token leftBracket = literal.leftBracket;
+    expect(leftBracket, isNotNull);
+    expect(leftBracket.precedingComments, isNotNull);
+    expect(literal.elements, hasLength(0));
+    expect(literal.rightBracket, isNotNull);
+  }
+
+  void test_parseListLiteral_empty_twoTokens() {
+    Token token = TokenFactory.tokenFromKeyword(Keyword.CONST);
+    ListLiteral literal = parseListLiteral(token, null, '[ ]');
+    expect(literal, isNotNull);
+    assertNoErrors();
+    expect(literal.constKeyword.keyword, Keyword.CONST);
+    expect(literal.typeArguments, isNull);
+    expect(literal.leftBracket, isNotNull);
+    expect(literal.elements, hasLength(0));
+    expect(literal.rightBracket, isNotNull);
+  }
+
+  void test_parseListLiteral_multiple() {
+    ListLiteral literal = parseListLiteral(null, null, '[1, 2, 3]');
+    expect(literal, isNotNull);
+    assertNoErrors();
+    expect(literal.constKeyword, isNull);
+    expect(literal.typeArguments, isNull);
+    expect(literal.leftBracket, isNotNull);
+    expect(literal.elements, hasLength(3));
+    expect(literal.rightBracket, isNotNull);
+  }
+
+  void test_parseListLiteral_single() {
+    ListLiteral literal = parseListLiteral(null, null, '[1]');
+    expect(literal, isNotNull);
+    assertNoErrors();
+    expect(literal.constKeyword, isNull);
+    expect(literal.typeArguments, isNull);
+    expect(literal.leftBracket, isNotNull);
+    expect(literal.elements, hasLength(1));
+    expect(literal.rightBracket, isNotNull);
+  }
+
+  void test_parseListLiteral_single_withTypeArgument() {
+    ListLiteral literal = parseListLiteral(null, '<int>', '[1]');
+    expect(literal, isNotNull);
+    assertNoErrors();
+    expect(literal.constKeyword, isNull);
+    expect(literal.typeArguments, isNotNull);
+    expect(literal.leftBracket, isNotNull);
+    expect(literal.elements, hasLength(1));
+    expect(literal.rightBracket, isNotNull);
+  }
+
+  void test_parseListOrMapLiteral_list_noType() {
+    TypedLiteral literal = parseListOrMapLiteral(null, '[1]');
+    expect(literal, isNotNull);
+    assertNoErrors();
+    var listLiteral = literal as ListLiteral;
+    expect(listLiteral.constKeyword, isNull);
+    expect(listLiteral.typeArguments, isNull);
+    expect(listLiteral.leftBracket, isNotNull);
+    expect(listLiteral.elements, hasLength(1));
+    expect(listLiteral.rightBracket, isNotNull);
+  }
+
+  void test_parseListOrMapLiteral_list_type() {
+    TypedLiteral literal = parseListOrMapLiteral(null, '<int> [1]');
+    expect(literal, isNotNull);
+    assertNoErrors();
+    var listLiteral = literal as ListLiteral;
+    expect(listLiteral.constKeyword, isNull);
+    expect(listLiteral.typeArguments, isNotNull);
+    expect(listLiteral.leftBracket, isNotNull);
+    expect(listLiteral.elements, hasLength(1));
+    expect(listLiteral.rightBracket, isNotNull);
+  }
+
+  void test_parseListOrMapLiteral_map_noType() {
+    TypedLiteral literal = parseListOrMapLiteral(null, "{'1' : 1}");
+    expect(literal, isNotNull);
+    assertNoErrors();
+    var mapLiteral = literal as SetOrMapLiteral;
+    expect(mapLiteral.constKeyword, isNull);
+    expect(mapLiteral.typeArguments, isNull);
+    expect(mapLiteral.leftBracket, isNotNull);
+    expect(mapLiteral.elements, hasLength(1));
+    expect(mapLiteral.rightBracket, isNotNull);
+  }
+
+  void test_parseListOrMapLiteral_map_type() {
+    TypedLiteral literal =
+        parseListOrMapLiteral(null, "<String, int> {'1' : 1}");
+    expect(literal, isNotNull);
+    assertNoErrors();
+    var mapLiteral = literal as SetOrMapLiteral;
+    expect(mapLiteral.constKeyword, isNull);
+    expect(mapLiteral.typeArguments, isNotNull);
+    expect(mapLiteral.leftBracket, isNotNull);
+    expect(mapLiteral.elements, hasLength(1));
+    expect(mapLiteral.rightBracket, isNotNull);
+  }
+
+  void test_parseLogicalAndExpression() {
+    Expression expression = parseLogicalAndExpression('x && y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var binaryExpression = expression as BinaryExpression;
+    expect(binaryExpression.leftOperand, isNotNull);
+    expect(binaryExpression.operator, isNotNull);
+    expect(binaryExpression.operator.type, TokenType.AMPERSAND_AMPERSAND);
+    expect(binaryExpression.rightOperand, isNotNull);
+  }
+
+  void test_parseLogicalOrExpression() {
+    Expression expression = parseLogicalOrExpression('x || y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var binaryExpression = expression as BinaryExpression;
+    expect(binaryExpression.leftOperand, isNotNull);
+    expect(binaryExpression.operator, isNotNull);
+    expect(binaryExpression.operator.type, TokenType.BAR_BAR);
+    expect(binaryExpression.rightOperand, isNotNull);
+  }
+
+  void test_parseMapLiteral_empty() {
+    Token token = TokenFactory.tokenFromKeyword(Keyword.CONST);
+    SetOrMapLiteral literal = parseMapLiteral(token, '<String, int>', '{}');
+    expect(literal, isNotNull);
+    assertNoErrors();
+    expect(literal.constKeyword.keyword, Keyword.CONST);
+    expect(literal.typeArguments, isNotNull);
+    expect(literal.leftBracket, isNotNull);
+    expect(literal.elements, hasLength(0));
+    expect(literal.rightBracket, isNotNull);
+  }
+
+  void test_parseMapLiteral_multiple() {
+    SetOrMapLiteral literal = parseMapLiteral(null, null, "{'a' : b, 'x' : y}");
+    expect(literal, isNotNull);
+    assertNoErrors();
+    expect(literal.leftBracket, isNotNull);
+    expect(literal.elements, hasLength(2));
+    expect(literal.rightBracket, isNotNull);
+  }
+
+  void test_parseMapLiteral_multiple_trailing_comma() {
+    SetOrMapLiteral literal =
+        parseMapLiteral(null, null, "{'a' : b, 'x' : y,}");
+    expect(literal, isNotNull);
+    assertNoErrors();
+    expect(literal.leftBracket, isNotNull);
+    expect(literal.elements, hasLength(2));
+    expect(literal.rightBracket, isNotNull);
+  }
+
+  void test_parseMapLiteral_single() {
+    SetOrMapLiteral literal = parseMapLiteral(null, null, "{'x' : y}");
+    expect(literal, isNotNull);
+    assertNoErrors();
+    expect(literal.leftBracket, isNotNull);
+    expect(literal.elements, hasLength(1));
+    expect(literal.rightBracket, isNotNull);
+  }
+
+  void test_parseMapLiteralEntry_complex() {
+    MapLiteralEntry entry = parseMapLiteralEntry('2 + 2 : y');
+    expect(entry, isNotNull);
+    assertNoErrors();
+    expect(entry.key, isNotNull);
+    expect(entry.separator, isNotNull);
+    expect(entry.value, isNotNull);
+  }
+
+  void test_parseMapLiteralEntry_int() {
+    MapLiteralEntry entry = parseMapLiteralEntry('0 : y');
+    expect(entry, isNotNull);
+    assertNoErrors();
+    expect(entry.key, isNotNull);
+    expect(entry.separator, isNotNull);
+    expect(entry.value, isNotNull);
+  }
+
+  void test_parseMapLiteralEntry_string() {
+    MapLiteralEntry entry = parseMapLiteralEntry("'x' : y");
+    expect(entry, isNotNull);
+    assertNoErrors();
+    expect(entry.key, isNotNull);
+    expect(entry.separator, isNotNull);
+    expect(entry.value, isNotNull);
+  }
+
+  void test_parseMultiplicativeExpression_normal() {
+    Expression expression = parseMultiplicativeExpression('x * y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var binaryExpression = expression as BinaryExpression;
+    expect(binaryExpression.leftOperand, isNotNull);
+    expect(binaryExpression.operator, isNotNull);
+    expect(binaryExpression.operator.type, TokenType.STAR);
+    expect(binaryExpression.rightOperand, isNotNull);
+  }
+
+  void test_parseMultiplicativeExpression_super() {
+    Expression expression = parseMultiplicativeExpression('super * y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var binaryExpression = expression as BinaryExpression;
+    expect(binaryExpression.leftOperand, isSuperExpression);
+    expect(binaryExpression.operator, isNotNull);
+    expect(binaryExpression.operator.type, TokenType.STAR);
+    expect(binaryExpression.rightOperand, isNotNull);
+  }
+
+  void test_parseNewExpression() {
+    InstanceCreationExpression expression = parseNewExpression('new A()');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.keyword, isNotNull);
+    ConstructorName name = expression.constructorName;
+    expect(name, isNotNull);
+    expect(name.type, isNotNull);
+    expect(name.period, isNull);
+    expect(name.name, isNull);
+    expect(expression.argumentList, isNotNull);
+  }
+
+  void test_parsePostfixExpression_decrement() {
+    Expression expression = parsePostfixExpression('i--');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var postfixExpression = expression as PostfixExpression;
+    expect(postfixExpression.operand, isNotNull);
+    expect(postfixExpression.operator, isNotNull);
+    expect(postfixExpression.operator.type, TokenType.MINUS_MINUS);
+  }
+
+  void test_parsePostfixExpression_increment() {
+    Expression expression = parsePostfixExpression('i++');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var postfixExpression = expression as PostfixExpression;
+    expect(postfixExpression.operand, isNotNull);
+    expect(postfixExpression.operator, isNotNull);
+    expect(postfixExpression.operator.type, TokenType.PLUS_PLUS);
+  }
+
+  void test_parsePostfixExpression_none_indexExpression() {
+    Expression expression = parsePostfixExpression('a[0]');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var indexExpression = expression as IndexExpression;
+    expect(indexExpression.target, isNotNull);
+    expect(indexExpression.index, isNotNull);
+  }
+
+  void test_parsePostfixExpression_none_methodInvocation() {
+    Expression expression = parsePostfixExpression('a.m()');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var methodInvocation = expression as MethodInvocation;
+    expect(methodInvocation.target, isNotNull);
+    expect(methodInvocation.operator.type, TokenType.PERIOD);
+    expect(methodInvocation.methodName, isNotNull);
+    expect(methodInvocation.typeArguments, isNull);
+    expect(methodInvocation.argumentList, isNotNull);
+  }
+
+  void test_parsePostfixExpression_none_methodInvocation_question_dot() {
+    Expression expression = parsePostfixExpression('a?.m()');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var methodInvocation = expression as MethodInvocation;
+    expect(methodInvocation.target, isNotNull);
+    expect(methodInvocation.operator.type, TokenType.QUESTION_PERIOD);
+    expect(methodInvocation.methodName, isNotNull);
+    expect(methodInvocation.typeArguments, isNull);
+    expect(methodInvocation.argumentList, isNotNull);
+  }
+
+  void
+      test_parsePostfixExpression_none_methodInvocation_question_dot_typeArguments() {
+    Expression expression = parsePostfixExpression('a?.m<E>()');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var methodInvocation = expression as MethodInvocation;
+    expect(methodInvocation.target, isNotNull);
+    expect(methodInvocation.operator.type, TokenType.QUESTION_PERIOD);
+    expect(methodInvocation.methodName, isNotNull);
+    expect(methodInvocation.typeArguments, isNotNull);
+    expect(methodInvocation.argumentList, isNotNull);
+  }
+
+  void test_parsePostfixExpression_none_methodInvocation_typeArguments() {
+    Expression expression = parsePostfixExpression('a.m<E>()');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var methodInvocation = expression as MethodInvocation;
+    expect(methodInvocation.target, isNotNull);
+    expect(methodInvocation.operator.type, TokenType.PERIOD);
+    expect(methodInvocation.methodName, isNotNull);
+    expect(methodInvocation.typeArguments, isNotNull);
+    expect(methodInvocation.argumentList, isNotNull);
+  }
+
+  void test_parsePostfixExpression_none_propertyAccess() {
+    Expression expression = parsePostfixExpression('a.b');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var identifier = expression as PrefixedIdentifier;
+    expect(identifier.prefix, isNotNull);
+    expect(identifier.identifier, isNotNull);
+  }
+
+  void test_parsePrefixedIdentifier_noPrefix() {
+    String lexeme = "bar";
+    Identifier identifier = parsePrefixedIdentifier(lexeme);
+    expect(identifier, isNotNull);
+    assertNoErrors();
+    var simpleIdentifier = identifier as SimpleIdentifier;
+    expect(simpleIdentifier.token, isNotNull);
+    expect(simpleIdentifier.name, lexeme);
+  }
+
+  void test_parsePrefixedIdentifier_prefix() {
+    String lexeme = "foo.bar";
+    Identifier identifier = parsePrefixedIdentifier(lexeme);
+    expect(identifier, isNotNull);
+    assertNoErrors();
+    var prefixedIdentifier = identifier as PrefixedIdentifier;
+    expect(prefixedIdentifier.prefix.name, "foo");
+    expect(prefixedIdentifier.period, isNotNull);
+    expect(prefixedIdentifier.identifier.name, "bar");
+  }
+
+  void test_parsePrimaryExpression_const() {
+    Expression expression = parsePrimaryExpression('const A()');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression, isNotNull);
+  }
+
+  void test_parsePrimaryExpression_double() {
+    String doubleLiteral = "3.2e4";
+    Expression expression = parsePrimaryExpression(doubleLiteral);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as DoubleLiteral;
+    expect(literal.literal, isNotNull);
+    expect(literal.value, double.parse(doubleLiteral));
+  }
+
+  void test_parsePrimaryExpression_false() {
+    Expression expression = parsePrimaryExpression('false');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as BooleanLiteral;
+    expect(literal.literal, isNotNull);
+    expect(literal.value, isFalse);
+  }
+
+  void test_parsePrimaryExpression_function_arguments() {
+    Expression expression = parsePrimaryExpression('(int i) => i + 1');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var functionExpression = expression as FunctionExpression;
+    expect(functionExpression.parameters, isNotNull);
+    expect(functionExpression.body, isNotNull);
+  }
+
+  void test_parsePrimaryExpression_function_noArguments() {
+    Expression expression = parsePrimaryExpression('() => 42');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var functionExpression = expression as FunctionExpression;
+    expect(functionExpression.parameters, isNotNull);
+    expect(functionExpression.body, isNotNull);
+  }
+
+  void test_parsePrimaryExpression_genericFunctionExpression() {
+    Expression expression =
+        parsePrimaryExpression('<X, Y>(Map<X, Y> m, X x) => m[x]');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var functionExpression = expression as FunctionExpression;
+    expect(functionExpression.typeParameters, isNotNull);
+  }
+
+  void test_parsePrimaryExpression_hex() {
+    String hexLiteral = "3F";
+    Expression expression = parsePrimaryExpression('0x$hexLiteral');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as IntegerLiteral;
+    expect(literal.literal, isNotNull);
+    expect(literal.value, int.parse(hexLiteral, radix: 16));
+  }
+
+  void test_parsePrimaryExpression_identifier() {
+    Expression expression = parsePrimaryExpression('a');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var identifier = expression as SimpleIdentifier;
+    expect(identifier, isNotNull);
+  }
+
+  void test_parsePrimaryExpression_int() {
+    String intLiteral = "472";
+    Expression expression = parsePrimaryExpression(intLiteral);
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as IntegerLiteral;
+    expect(literal.literal, isNotNull);
+    expect(literal.value, int.parse(intLiteral));
+  }
+
+  void test_parsePrimaryExpression_listLiteral() {
+    Expression expression = parsePrimaryExpression('[ ]');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as ListLiteral;
+    expect(literal, isNotNull);
+  }
+
+  void test_parsePrimaryExpression_listLiteral_index() {
+    Expression expression = parsePrimaryExpression('[]');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as ListLiteral;
+    expect(literal, isNotNull);
+  }
+
+  void test_parsePrimaryExpression_listLiteral_typed() {
+    Expression expression = parsePrimaryExpression('<A>[ ]');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as ListLiteral;
+    expect(literal.typeArguments, isNotNull);
+    expect(literal.typeArguments.arguments, hasLength(1));
+  }
+
+  void test_parsePrimaryExpression_mapLiteral() {
+    Expression expression = parsePrimaryExpression('{}');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as SetOrMapLiteral;
+    expect(literal.typeArguments, isNull);
+    expect(literal, isNotNull);
+  }
+
+  void test_parsePrimaryExpression_mapLiteral_typed() {
+    Expression expression = parsePrimaryExpression('<A, B>{}');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as SetOrMapLiteral;
+    expect(literal.typeArguments, isNotNull);
+    expect(literal.typeArguments.arguments, hasLength(2));
+  }
+
+  void test_parsePrimaryExpression_new() {
+    Expression expression = parsePrimaryExpression('new A()');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var creation = expression as InstanceCreationExpression;
+    expect(creation, isNotNull);
+  }
+
+  void test_parsePrimaryExpression_null() {
+    Expression expression = parsePrimaryExpression('null');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression, isNullLiteral);
+    NullLiteral literal = expression;
+    expect(literal.literal, isNotNull);
+  }
+
+  void test_parsePrimaryExpression_parenthesized() {
+    Expression expression = parsePrimaryExpression('(x)');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var parens = expression as ParenthesizedExpression;
+    expect(parens, isNotNull);
+  }
+
+  void test_parsePrimaryExpression_string() {
+    Expression expression = parsePrimaryExpression('"string"');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as SimpleStringLiteral;
+    expect(literal.isMultiline, isFalse);
+    expect(literal.isRaw, isFalse);
+    expect(literal.value, "string");
+  }
+
+  void test_parsePrimaryExpression_string_multiline() {
+    Expression expression = parsePrimaryExpression("'''string'''");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as SimpleStringLiteral;
+    expect(literal.isMultiline, isTrue);
+    expect(literal.isRaw, isFalse);
+    expect(literal.value, "string");
+  }
+
+  void test_parsePrimaryExpression_string_raw() {
+    Expression expression = parsePrimaryExpression("r'string'");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as SimpleStringLiteral;
+    expect(literal.isMultiline, isFalse);
+    expect(literal.isRaw, isTrue);
+    expect(literal.value, "string");
+  }
+
+  void test_parsePrimaryExpression_super() {
+    Expression expression = parseExpression('super.x');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var propertyAccess = expression as PropertyAccess;
+    expect(propertyAccess.target is SuperExpression, isTrue);
+    expect(propertyAccess.operator, isNotNull);
+    expect(propertyAccess.operator.type, TokenType.PERIOD);
+    expect(propertyAccess.propertyName, isNotNull);
+  }
+
+  void test_parsePrimaryExpression_this() {
+    Expression expression = parsePrimaryExpression('this');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var thisExpression = expression as ThisExpression;
+    expect(thisExpression.thisKeyword, isNotNull);
+  }
+
+  void test_parsePrimaryExpression_true() {
+    Expression expression = parsePrimaryExpression('true');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as BooleanLiteral;
+    expect(literal.literal, isNotNull);
+    expect(literal.value, isTrue);
+  }
+
+  void test_parseRedirectingConstructorInvocation_named() {
+    var invocation = parseConstructorInitializer('this.a()')
+        as RedirectingConstructorInvocation;
+    assertNoErrors();
+    expect(invocation.argumentList, isNotNull);
+    expect(invocation.constructorName, isNotNull);
+    expect(invocation.thisKeyword, isNotNull);
+    expect(invocation.period, isNotNull);
+  }
+
+  void test_parseRedirectingConstructorInvocation_unnamed() {
+    var invocation = parseConstructorInitializer('this()')
+        as RedirectingConstructorInvocation;
+    assertNoErrors();
+    expect(invocation.argumentList, isNotNull);
+    expect(invocation.constructorName, isNull);
+    expect(invocation.thisKeyword, isNotNull);
+    expect(invocation.period, isNull);
+  }
+
+  void test_parseRelationalExpression_as_chained() {
+    AsExpression asExpression = parseExpression('x as Y as Z',
+        errors: [expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 7, 2)]);
+    expect(asExpression, isNotNull);
+    SimpleIdentifier identifier = asExpression.expression;
+    expect(identifier.name, 'x');
+    expect(asExpression.asOperator, isNotNull);
+    TypeName typeName = asExpression.type;
+    expect(typeName.name.name, 'Y');
+  }
+
+  void test_parseRelationalExpression_as_functionType_noReturnType() {
+    Expression expression = parseRelationalExpression('x as Function(int)');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var asExpression = expression as AsExpression;
+    expect(asExpression.expression, isNotNull);
+    expect(asExpression.asOperator, isNotNull);
+    expect(asExpression.type, isGenericFunctionType);
+  }
+
+  void test_parseRelationalExpression_as_functionType_returnType() {
+    Expression expression =
+        parseRelationalExpression('x as String Function(int)');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var asExpression = expression as AsExpression;
+    expect(asExpression.expression, isNotNull);
+    expect(asExpression.asOperator, isNotNull);
+    expect(asExpression.type, isGenericFunctionType);
+  }
+
+  void test_parseRelationalExpression_as_generic() {
+    Expression expression = parseRelationalExpression('x as C<D>');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var asExpression = expression as AsExpression;
+    expect(asExpression.expression, isNotNull);
+    expect(asExpression.asOperator, isNotNull);
+    expect(asExpression.type, isTypeName);
+  }
+
+  void test_parseRelationalExpression_as_simple() {
+    Expression expression = parseRelationalExpression('x as Y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var asExpression = expression as AsExpression;
+    expect(asExpression.expression, isNotNull);
+    expect(asExpression.asOperator, isNotNull);
+    expect(asExpression.type, isTypeName);
+  }
+
+  void test_parseRelationalExpression_as_simple_function() {
+    Expression expression = parseRelationalExpression('x as Function');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var asExpression = expression as AsExpression;
+    expect(asExpression.expression, isNotNull);
+    expect(asExpression.asOperator, isNotNull);
+    expect(asExpression.type, isTypeName);
+  }
+
+  void test_parseRelationalExpression_is() {
+    Expression expression = parseRelationalExpression('x is y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var isExpression = expression as IsExpression;
+    expect(isExpression.expression, isNotNull);
+    expect(isExpression.isOperator, isNotNull);
+    expect(isExpression.notOperator, isNull);
+    expect(isExpression.type, isNotNull);
+  }
+
+  void test_parseRelationalExpression_is_chained() {
+    IsExpression isExpression = parseExpression('x is Y is! Z',
+        errors: [expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 7, 2)]);
+    expect(isExpression, isNotNull);
+    SimpleIdentifier identifier = isExpression.expression;
+    expect(identifier.name, 'x');
+    expect(isExpression.isOperator, isNotNull);
+    TypeName typeName = isExpression.type;
+    expect(typeName.name.name, 'Y');
+  }
+
+  void test_parseRelationalExpression_isNot() {
+    Expression expression = parseRelationalExpression('x is! y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var isExpression = expression as IsExpression;
+    expect(isExpression.expression, isNotNull);
+    expect(isExpression.isOperator, isNotNull);
+    expect(isExpression.notOperator, isNotNull);
+    expect(isExpression.type, isNotNull);
+  }
+
+  void test_parseRelationalExpression_normal() {
+    Expression expression = parseRelationalExpression('x < y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var binaryExpression = expression as BinaryExpression;
+    expect(binaryExpression.leftOperand, isNotNull);
+    expect(binaryExpression.operator, isNotNull);
+    expect(binaryExpression.operator.type, TokenType.LT);
+    expect(binaryExpression.rightOperand, isNotNull);
+  }
+
+  void test_parseRelationalExpression_super() {
+    Expression expression = parseRelationalExpression('super < y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var binaryExpression = expression as BinaryExpression;
+    expect(binaryExpression.leftOperand, isNotNull);
+    expect(binaryExpression.operator, isNotNull);
+    expect(binaryExpression.operator.type, TokenType.LT);
+    expect(binaryExpression.rightOperand, isNotNull);
+  }
+
+  void test_parseRethrowExpression() {
+    RethrowExpression expression = parseRethrowExpression('rethrow');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.rethrowKeyword, isNotNull);
+  }
+
+  void test_parseShiftExpression_normal() {
+    BinaryExpression expression = parseShiftExpression('x << y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.leftOperand, isNotNull);
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.LT_LT);
+    expect(expression.rightOperand, isNotNull);
+  }
+
+  void test_parseShiftExpression_super() {
+    BinaryExpression expression = parseShiftExpression('super << y');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.leftOperand, isNotNull);
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.LT_LT);
+    expect(expression.rightOperand, isNotNull);
+  }
+
+  void test_parseSimpleIdentifier1_normalIdentifier() {
+    // TODO(brianwilkerson) Implement tests for this method.
+  }
+
+  void test_parseSimpleIdentifier_builtInIdentifier() {
+    String lexeme = "as";
+    SimpleIdentifier identifier = parseSimpleIdentifier(lexeme);
+    expect(identifier, isNotNull);
+    assertNoErrors();
+    expect(identifier.token, isNotNull);
+    expect(identifier.name, lexeme);
+  }
+
+  void test_parseSimpleIdentifier_normalIdentifier() {
+    String lexeme = "foo";
+    SimpleIdentifier identifier = parseSimpleIdentifier(lexeme);
+    expect(identifier, isNotNull);
+    assertNoErrors();
+    expect(identifier.token, isNotNull);
+    expect(identifier.name, lexeme);
+  }
+
+  void test_parseStringLiteral_adjacent() {
+    Expression expression = parseStringLiteral("'a' 'b'");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as AdjacentStrings;
+    NodeList<StringLiteral> strings = literal.strings;
+    expect(strings, hasLength(2));
+    StringLiteral firstString = strings[0];
+    StringLiteral secondString = strings[1];
+    expect((firstString as SimpleStringLiteral).value, "a");
+    expect((secondString as SimpleStringLiteral).value, "b");
+  }
+
+  void test_parseStringLiteral_endsWithInterpolation() {
+    Expression expression = parseStringLiteral(r"'x$y'");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var interpolation = expression as StringInterpolation;
+    expect(interpolation.elements, hasLength(3));
+    expect(interpolation.elements[0], isInterpolationString);
+    InterpolationString element0 = interpolation.elements[0];
+    expect(element0.value, 'x');
+    expect(interpolation.elements[1], isInterpolationExpression);
+    InterpolationExpression element1 = interpolation.elements[1];
+    expect(element1.leftBracket.lexeme, '\$');
+    expect(element1.expression, isSimpleIdentifier);
+    expect(element1.rightBracket, isNull);
+    expect(interpolation.elements[2], isInterpolationString);
+    InterpolationString element2 = interpolation.elements[2];
+    expect(element2.value, '');
+  }
+
+  void test_parseStringLiteral_interpolated() {
+    Expression expression = parseStringLiteral("'a \${b} c \$this d'");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression, isStringInterpolation);
+    StringInterpolation literal = expression;
+    NodeList<InterpolationElement> elements = literal.elements;
+    expect(elements, hasLength(5));
+    expect(elements[0] is InterpolationString, isTrue);
+    expect(elements[1] is InterpolationExpression, isTrue);
+    expect(elements[2] is InterpolationString, isTrue);
+    expect(elements[3] is InterpolationExpression, isTrue);
+    expect(elements[4] is InterpolationString, isTrue);
+    expect((elements[1] as InterpolationExpression).leftBracket.lexeme, '\${');
+    expect((elements[1] as InterpolationExpression).rightBracket.lexeme, '}');
+    expect((elements[3] as InterpolationExpression).leftBracket.lexeme, '\$');
+    expect((elements[3] as InterpolationExpression).rightBracket, isNull);
+  }
+
+  void test_parseStringLiteral_interpolated_void() {
+    Expression expression = parseStringLiteral(r"'<html>$void</html>'");
+    expect(expression, isNotNull);
+    assertErrors(errors: [
+      expectedError(ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD, 8, 4)
+    ]);
+    expect(expression, isStringInterpolation);
+    var literal = expression as StringInterpolation;
+    NodeList<InterpolationElement> elements = literal.elements;
+    expect(elements, hasLength(3));
+    expect(elements[0] is InterpolationString, isTrue);
+    expect(elements[1] is InterpolationExpression, isTrue);
+    expect(elements[2] is InterpolationString, isTrue);
+    expect((elements[1] as InterpolationExpression).leftBracket.lexeme, '\$');
+    expect((elements[1] as InterpolationExpression).rightBracket, isNull);
+  }
+
+  void test_parseStringLiteral_multiline_encodedSpace() {
+    Expression expression = parseStringLiteral("'''\\x20\na'''");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as SimpleStringLiteral;
+    expect(literal.literal, isNotNull);
+    expect(literal.value, " \na");
+  }
+
+  void test_parseStringLiteral_multiline_endsWithInterpolation() {
+    Expression expression = parseStringLiteral(r"'''x$y'''");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var interpolation = expression as StringInterpolation;
+    expect(interpolation.elements, hasLength(3));
+    expect(interpolation.elements[0], isInterpolationString);
+    InterpolationString element0 = interpolation.elements[0];
+    expect(element0.value, 'x');
+    expect(interpolation.elements[1], isInterpolationExpression);
+    InterpolationExpression element1 = interpolation.elements[1];
+    expect(element1.expression, isSimpleIdentifier);
+    expect(interpolation.elements[2], isInterpolationString);
+    InterpolationString element2 = interpolation.elements[2];
+    expect(element2.value, '');
+  }
+
+  void test_parseStringLiteral_multiline_escapedBackslash() {
+    Expression expression = parseStringLiteral("'''\\\\\na'''");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as SimpleStringLiteral;
+    expect(literal.literal, isNotNull);
+    expect(literal.value, "\\\na");
+  }
+
+  void test_parseStringLiteral_multiline_escapedBackslash_raw() {
+    Expression expression = parseStringLiteral("r'''\\\\\na'''");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as SimpleStringLiteral;
+    expect(literal.literal, isNotNull);
+    expect(literal.value, "\\\\\na");
+  }
+
+  void test_parseStringLiteral_multiline_escapedEolMarker() {
+    Expression expression = parseStringLiteral("'''\\\na'''");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as SimpleStringLiteral;
+    expect(literal.literal, isNotNull);
+    expect(literal.value, "a");
+  }
+
+  void test_parseStringLiteral_multiline_escapedEolMarker_raw() {
+    Expression expression = parseStringLiteral("r'''\\\na'''");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as SimpleStringLiteral;
+    expect(literal.literal, isNotNull);
+    expect(literal.value, "a");
+  }
+
+  void test_parseStringLiteral_multiline_escapedSpaceAndEolMarker() {
+    Expression expression = parseStringLiteral("'''\\ \\\na'''");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as SimpleStringLiteral;
+    expect(literal.literal, isNotNull);
+    expect(literal.value, "a");
+  }
+
+  void test_parseStringLiteral_multiline_escapedSpaceAndEolMarker_raw() {
+    Expression expression = parseStringLiteral("r'''\\ \\\na'''");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as SimpleStringLiteral;
+    expect(literal.literal, isNotNull);
+    expect(literal.value, "a");
+  }
+
+  void test_parseStringLiteral_multiline_escapedTab() {
+    Expression expression = parseStringLiteral("'''\\t\na'''");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as SimpleStringLiteral;
+    expect(literal.literal, isNotNull);
+    expect(literal.value, "\t\na");
+  }
+
+  void test_parseStringLiteral_multiline_escapedTab_raw() {
+    Expression expression = parseStringLiteral("r'''\\t\na'''");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as SimpleStringLiteral;
+    expect(literal.literal, isNotNull);
+    expect(literal.value, "\\t\na");
+  }
+
+  void test_parseStringLiteral_multiline_quoteAfterInterpolation() {
+    Expression expression = parseStringLiteral(r"""'''$x'y'''""");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var interpolation = expression as StringInterpolation;
+    expect(interpolation.elements, hasLength(3));
+    expect(interpolation.elements[0], isInterpolationString);
+    InterpolationString element0 = interpolation.elements[0];
+    expect(element0.value, '');
+    expect(interpolation.elements[1], isInterpolationExpression);
+    InterpolationExpression element1 = interpolation.elements[1];
+    expect(element1.expression, isSimpleIdentifier);
+    expect(interpolation.elements[2], isInterpolationString);
+    InterpolationString element2 = interpolation.elements[2];
+    expect(element2.value, "'y");
+  }
+
+  void test_parseStringLiteral_multiline_startsWithInterpolation() {
+    Expression expression = parseStringLiteral(r"'''${x}y'''");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var interpolation = expression as StringInterpolation;
+    expect(interpolation.elements, hasLength(3));
+    expect(interpolation.elements[0], isInterpolationString);
+    InterpolationString element0 = interpolation.elements[0];
+    expect(element0.value, '');
+    expect(interpolation.elements[1], isInterpolationExpression);
+    InterpolationExpression element1 = interpolation.elements[1];
+    expect(element1.expression, isSimpleIdentifier);
+    expect(interpolation.elements[2], isInterpolationString);
+    InterpolationString element2 = interpolation.elements[2];
+    expect(element2.value, 'y');
+  }
+
+  void test_parseStringLiteral_multiline_twoSpaces() {
+    Expression expression = parseStringLiteral("'''  \na'''");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as SimpleStringLiteral;
+    expect(literal.literal, isNotNull);
+    expect(literal.value, "a");
+  }
+
+  void test_parseStringLiteral_multiline_twoSpaces_raw() {
+    Expression expression = parseStringLiteral("r'''  \na'''");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as SimpleStringLiteral;
+    expect(literal.literal, isNotNull);
+    expect(literal.value, "a");
+  }
+
+  void test_parseStringLiteral_multiline_untrimmed() {
+    Expression expression = parseStringLiteral("''' a\nb'''");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as SimpleStringLiteral;
+    expect(literal.literal, isNotNull);
+    expect(literal.value, " a\nb");
+  }
+
+  void test_parseStringLiteral_quoteAfterInterpolation() {
+    Expression expression = parseStringLiteral(r"""'$x"'""");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var interpolation = expression as StringInterpolation;
+    expect(interpolation.elements, hasLength(3));
+    expect(interpolation.elements[0], isInterpolationString);
+    InterpolationString element0 = interpolation.elements[0];
+    expect(element0.value, '');
+    expect(interpolation.elements[1], isInterpolationExpression);
+    InterpolationExpression element1 = interpolation.elements[1];
+    expect(element1.expression, isSimpleIdentifier);
+    expect(interpolation.elements[2], isInterpolationString);
+    InterpolationString element2 = interpolation.elements[2];
+    expect(element2.value, '"');
+  }
+
+  void test_parseStringLiteral_single() {
+    Expression expression = parseStringLiteral("'a'");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var literal = expression as SimpleStringLiteral;
+    expect(literal.literal, isNotNull);
+    expect(literal.value, "a");
+  }
+
+  void test_parseStringLiteral_startsWithInterpolation() {
+    Expression expression = parseStringLiteral(r"'${x}y'");
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var interpolation = expression as StringInterpolation;
+    expect(interpolation.elements, hasLength(3));
+    expect(interpolation.elements[0], isInterpolationString);
+    InterpolationString element0 = interpolation.elements[0];
+    expect(element0.value, '');
+    expect(interpolation.elements[1], isInterpolationExpression);
+    InterpolationExpression element1 = interpolation.elements[1];
+    expect(element1.expression, isSimpleIdentifier);
+    expect(interpolation.elements[2], isInterpolationString);
+    InterpolationString element2 = interpolation.elements[2];
+    expect(element2.value, 'y');
+  }
+
+  void test_parseSuperConstructorInvocation_named() {
+    var invocation =
+        parseConstructorInitializer('super.a()') as SuperConstructorInvocation;
+    expect(invocation, isNotNull);
+    assertNoErrors();
+    expect(invocation.argumentList, isNotNull);
+    expect(invocation.constructorName, isNotNull);
+    expect(invocation.superKeyword, isNotNull);
+    expect(invocation.period, isNotNull);
+  }
+
+  void test_parseSuperConstructorInvocation_unnamed() {
+    var invocation =
+        parseConstructorInitializer('super()') as SuperConstructorInvocation;
+    assertNoErrors();
+    expect(invocation.argumentList, isNotNull);
+    expect(invocation.constructorName, isNull);
+    expect(invocation.superKeyword, isNotNull);
+    expect(invocation.period, isNull);
+  }
+
+  void test_parseSymbolLiteral_builtInIdentifier() {
+    SymbolLiteral literal = parseSymbolLiteral('#dynamic.static.abstract');
+    expect(literal, isNotNull);
+    assertNoErrors();
+    expect(literal.poundSign, isNotNull);
+    List<Token> components = literal.components;
+    expect(components, hasLength(3));
+    expect(components[0].lexeme, "dynamic");
+    expect(components[1].lexeme, "static");
+    expect(components[2].lexeme, "abstract");
+  }
+
+  void test_parseSymbolLiteral_multiple() {
+    SymbolLiteral literal = parseSymbolLiteral('#a.b.c');
+    expect(literal, isNotNull);
+    assertNoErrors();
+    expect(literal.poundSign, isNotNull);
+    List<Token> components = literal.components;
+    expect(components, hasLength(3));
+    expect(components[0].lexeme, "a");
+    expect(components[1].lexeme, "b");
+    expect(components[2].lexeme, "c");
+  }
+
+  void test_parseSymbolLiteral_operator() {
+    SymbolLiteral literal = parseSymbolLiteral('#==');
+    expect(literal, isNotNull);
+    assertNoErrors();
+    expect(literal.poundSign, isNotNull);
+    List<Token> components = literal.components;
+    expect(components, hasLength(1));
+    expect(components[0].lexeme, "==");
+  }
+
+  void test_parseSymbolLiteral_single() {
+    SymbolLiteral literal = parseSymbolLiteral('#a');
+    expect(literal, isNotNull);
+    assertNoErrors();
+    expect(literal.poundSign, isNotNull);
+    List<Token> components = literal.components;
+    expect(components, hasLength(1));
+    expect(components[0].lexeme, "a");
+  }
+
+  void test_parseSymbolLiteral_void() {
+    SymbolLiteral literal = parseSymbolLiteral('#void');
+    expect(literal, isNotNull);
+    assertNoErrors();
+    expect(literal.poundSign, isNotNull);
+    List<Token> components = literal.components;
+    expect(components, hasLength(1));
+    expect(components[0].lexeme, "void");
+  }
+
+  void test_parseThrowExpression() {
+    Expression expression = parseThrowExpression('throw x');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var throwExpression = expression as ThrowExpression;
+    expect(throwExpression.throwKeyword, isNotNull);
+    expect(throwExpression.expression, isNotNull);
+  }
+
+  void test_parseThrowExpressionWithoutCascade() {
+    Expression expression = parseThrowExpressionWithoutCascade('throw x');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    var throwExpression = expression as ThrowExpression;
+    expect(throwExpression.throwKeyword, isNotNull);
+    expect(throwExpression.expression, isNotNull);
+  }
+
+  void test_parseUnaryExpression_decrement_identifier_index() {
+    PrefixExpression expression = parseExpression('--a[0]');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.MINUS_MINUS);
+    expect(expression.operand, isNotNull);
+    IndexExpression operand = expression.operand as IndexExpression;
+    expect(operand.realTarget, const TypeMatcher<SimpleIdentifier>());
+    expect(operand.index is IntegerLiteral, isTrue);
+  }
+
+  void test_parseUnaryExpression_decrement_normal() {
+    PrefixExpression expression = parseUnaryExpression('--x');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.MINUS_MINUS);
+    expect(expression.operand, isNotNull);
+  }
+
+  @failingTest
+  void test_parseUnaryExpression_decrement_super() {
+    // TODO(danrubel) Reports a different error and different token stream.
+    // Expected: TokenType:<MINUS>
+    //   Actual: TokenType:<MINUS_MINUS>
+    PrefixExpression expression = parseUnaryExpression('--super');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.MINUS);
+    Expression innerExpression = expression.operand;
+    expect(innerExpression, isNotNull);
+    expect(innerExpression is PrefixExpression, isTrue);
+    PrefixExpression operand = innerExpression as PrefixExpression;
+    expect(operand.operator, isNotNull);
+    expect(operand.operator.type, TokenType.MINUS);
+    expect(operand.operand, isNotNull);
+  }
+
+  void test_parseUnaryExpression_decrement_super_propertyAccess() {
+    PrefixExpression expression = parseUnaryExpression('--super.x');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.MINUS_MINUS);
+    expect(expression.operand, isNotNull);
+    PropertyAccess operand = expression.operand as PropertyAccess;
+    expect(operand.target is SuperExpression, isTrue);
+    expect(operand.propertyName.name, "x");
+  }
+
+  @failingTest
+  void test_parseUnaryExpression_decrement_super_withComment() {
+    // TODO(danrubel) Reports a different error and different token stream.
+    // Expected: TokenType:<MINUS>
+    //   Actual: TokenType:<MINUS_MINUS>
+
+    PrefixExpression expression = parseUnaryExpression('/* 0 */ --super');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.MINUS);
+    expect(expression.operator.precedingComments, isNotNull);
+    Expression innerExpression = expression.operand;
+    expect(innerExpression, isNotNull);
+    expect(innerExpression is PrefixExpression, isTrue);
+    PrefixExpression operand = innerExpression as PrefixExpression;
+    expect(operand.operator, isNotNull);
+    expect(operand.operator.type, TokenType.MINUS);
+    expect(operand.operand, isNotNull);
+  }
+
+  void test_parseUnaryExpression_increment_identifier_index() {
+    PrefixExpression expression = parseExpression('++a[0]');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.PLUS_PLUS);
+    expect(expression.operand, isNotNull);
+    IndexExpression operand = expression.operand as IndexExpression;
+    expect(operand.realTarget, const TypeMatcher<SimpleIdentifier>());
+    expect(operand.index is IntegerLiteral, isTrue);
+  }
+
+  void test_parseUnaryExpression_increment_normal() {
+    PrefixExpression expression = parseUnaryExpression('++x');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.PLUS_PLUS);
+    expect(expression.operand, isNotNull);
+  }
+
+  void test_parseUnaryExpression_increment_super_index() {
+    PrefixExpression expression = parseUnaryExpression('++super[0]');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.PLUS_PLUS);
+    expect(expression.operand, isNotNull);
+    IndexExpression operand = expression.operand as IndexExpression;
+    expect(operand.realTarget is SuperExpression, isTrue);
+    expect(operand.index is IntegerLiteral, isTrue);
+  }
+
+  void test_parseUnaryExpression_increment_super_propertyAccess() {
+    PrefixExpression expression = parseUnaryExpression('++super.x');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.PLUS_PLUS);
+    expect(expression.operand, isNotNull);
+    PropertyAccess operand = expression.operand as PropertyAccess;
+    expect(operand.target is SuperExpression, isTrue);
+    expect(operand.propertyName.name, "x");
+  }
+
+  void test_parseUnaryExpression_minus_identifier_index() {
+    PrefixExpression expression = parseExpression('-a[0]');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.MINUS);
+    expect(expression.operand, isNotNull);
+    IndexExpression operand = expression.operand as IndexExpression;
+    expect(operand.realTarget, const TypeMatcher<SimpleIdentifier>());
+    expect(operand.index is IntegerLiteral, isTrue);
+  }
+
+  void test_parseUnaryExpression_minus_normal() {
+    PrefixExpression expression = parseUnaryExpression('-x');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.MINUS);
+    expect(expression.operand, isNotNull);
+  }
+
+  void test_parseUnaryExpression_minus_super() {
+    PrefixExpression expression = parseUnaryExpression('-super');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.MINUS);
+    expect(expression.operand, isNotNull);
+  }
+
+  void test_parseUnaryExpression_not_normal() {
+    PrefixExpression expression = parseUnaryExpression('!x');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.BANG);
+    expect(expression.operand, isNotNull);
+  }
+
+  void test_parseUnaryExpression_not_super() {
+    PrefixExpression expression = parseUnaryExpression('!super');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.BANG);
+    expect(expression.operand, isNotNull);
+  }
+
+  void test_parseUnaryExpression_tilda_normal() {
+    PrefixExpression expression = parseUnaryExpression('~x');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.TILDE);
+    expect(expression.operand, isNotNull);
+  }
+
+  void test_parseUnaryExpression_tilda_super() {
+    PrefixExpression expression = parseUnaryExpression('~super');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.TILDE);
+    expect(expression.operand, isNotNull);
+  }
+
+  void test_parseUnaryExpression_tilde_identifier_index() {
+    PrefixExpression expression = parseExpression('~a[0]');
+    expect(expression, isNotNull);
+    assertNoErrors();
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.TILDE);
+    expect(expression.operand, isNotNull);
+    IndexExpression operand = expression.operand as IndexExpression;
+    expect(operand.realTarget, const TypeMatcher<SimpleIdentifier>());
+    expect(operand.index is IntegerLiteral, isTrue);
+  }
+
+  void test_setLiteral() {
+    SetOrMapLiteral set = parseExpression('{3}');
+    expect(set.constKeyword, isNull);
+    expect(set.typeArguments, isNull);
+    expect(set.elements, hasLength(1));
+    IntegerLiteral value = set.elements[0];
+    expect(value.value, 3);
+  }
+
+  void test_setLiteral_const() {
+    SetOrMapLiteral set = parseExpression('const {3, 6}');
+    expect(set.constKeyword, isNotNull);
+    expect(set.typeArguments, isNull);
+    expect(set.elements, hasLength(2));
+    IntegerLiteral value1 = set.elements[0];
+    expect(value1.value, 3);
+    IntegerLiteral value2 = set.elements[1];
+    expect(value2.value, 6);
+  }
+
+  void test_setLiteral_const_typed() {
+    SetOrMapLiteral set = parseExpression('const <int>{3}');
+    expect(set.constKeyword, isNotNull);
+    expect(set.typeArguments.arguments, hasLength(1));
+    NamedType typeArg = set.typeArguments.arguments[0];
+    expect(typeArg.name.name, 'int');
+    expect(set.elements.length, 1);
+    IntegerLiteral value = set.elements[0];
+    expect(value.value, 3);
+  }
+
+  void test_setLiteral_nested_typeArgument() {
+    SetOrMapLiteral set = parseExpression('<Set<int>>{{3}}');
+    expect(set.constKeyword, isNull);
+    expect(set.typeArguments.arguments, hasLength(1));
+    NamedType typeArg1 = set.typeArguments.arguments[0];
+    expect(typeArg1.name.name, 'Set');
+    expect(typeArg1.typeArguments.arguments, hasLength(1));
+    NamedType typeArg2 = typeArg1.typeArguments.arguments[0];
+    expect(typeArg2.name.name, 'int');
+    expect(set.elements.length, 1);
+    SetOrMapLiteral intSet = set.elements[0];
+    expect(intSet.elements, hasLength(1));
+    IntegerLiteral value = intSet.elements[0];
+    expect(value.value, 3);
+  }
+
+  void test_setLiteral_typed() {
+    SetOrMapLiteral set = parseExpression('<int>{3}');
+    expect(set.constKeyword, isNull);
+    expect(set.typeArguments.arguments, hasLength(1));
+    NamedType typeArg = set.typeArguments.arguments[0];
+    expect(typeArg.name.name, 'int');
+    expect(set.elements.length, 1);
+    IntegerLiteral value = set.elements[0];
+    expect(value.value, 3);
+  }
+}
diff --git a/pkg/analyzer/test/generated/extension_methods_parser_test.dart b/pkg/analyzer/test/generated/extension_methods_parser_test.dart
new file mode 100644
index 0000000..e5b42d3
--- /dev/null
+++ b/pkg/analyzer/test/generated/extension_methods_parser_test.dart
@@ -0,0 +1,261 @@
+// Copyright (c) 2020, 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.
+
+import 'package:analyzer/dart/analysis/features.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/ast/ast.dart' show CompilationUnitImpl;
+import 'package:analyzer/src/dart/scanner/scanner.dart';
+import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
+import 'package:pub_semver/src/version.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'parser_test_base.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(ExtensionMethodsParserTest);
+  });
+}
+
+@reflectiveTest
+class ExtensionMethodsParserTest extends FastaParserTestCase {
+  void test_complex_extends() {
+    var unit = parseCompilationUnit(
+        'extension E extends A with B, C implements D { }',
+        errors: [
+          expectedError(ParserErrorCode.EXPECTED_INSTEAD, 12, 7),
+          expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 22, 4),
+          expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 28, 1),
+          expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 32, 10),
+        ]);
+    expect(unit.declarations, hasLength(1));
+    var extension = unit.declarations[0] as ExtensionDeclaration;
+    expect(extension.name.name, 'E');
+    expect(extension.onKeyword.lexeme, 'extends');
+    expect((extension.extendedType as NamedType).name.name, 'A');
+    expect(extension.members, hasLength(0));
+  }
+
+  void test_complex_implements() {
+    var unit = parseCompilationUnit('extension E implements C, D { }', errors: [
+      expectedError(ParserErrorCode.EXPECTED_INSTEAD, 12, 10),
+      expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 24, 1),
+    ]);
+    expect(unit.declarations, hasLength(1));
+    var extension = unit.declarations[0] as ExtensionDeclaration;
+    expect(extension.name.name, 'E');
+    expect(extension.onKeyword.lexeme, 'implements');
+    expect((extension.extendedType as NamedType).name.name, 'C');
+    expect(extension.members, hasLength(0));
+  }
+
+  void test_complex_type() {
+    var unit = parseCompilationUnit('extension E on C<T> { }');
+    expect(unit.declarations, hasLength(1));
+    var extension = unit.declarations[0] as ExtensionDeclaration;
+    expect(extension.name.name, 'E');
+    expect(extension.onKeyword.lexeme, 'on');
+    var namedType = extension.extendedType as NamedType;
+    expect(namedType.name.name, 'C');
+    expect(namedType.typeArguments.arguments, hasLength(1));
+    expect(extension.members, hasLength(0));
+  }
+
+  void test_complex_type2() {
+    var unit = parseCompilationUnit('extension E<T> on C<T> { }');
+    expect(unit.declarations, hasLength(1));
+    var extension = unit.declarations[0] as ExtensionDeclaration;
+    expect(extension.name.name, 'E');
+    expect(extension.onKeyword.lexeme, 'on');
+    var namedType = extension.extendedType as NamedType;
+    expect(namedType.name.name, 'C');
+    expect(namedType.typeArguments.arguments, hasLength(1));
+    expect(extension.members, hasLength(0));
+  }
+
+  void test_complex_type2_no_name() {
+    var unit = parseCompilationUnit('extension<T> on C<T> { }');
+    expect(unit.declarations, hasLength(1));
+    var extension = unit.declarations[0] as ExtensionDeclaration;
+    expect(extension.name, isNull);
+    expect(extension.onKeyword.lexeme, 'on');
+    var namedType = extension.extendedType as NamedType;
+    expect(namedType.name.name, 'C');
+    expect(namedType.typeArguments.arguments, hasLength(1));
+    expect(extension.members, hasLength(0));
+  }
+
+  void test_constructor_named() {
+    var unit = parseCompilationUnit('''
+extension E on C {
+  E.named();
+}
+class C {}
+''', errors: [
+      expectedError(ParserErrorCode.EXTENSION_DECLARES_CONSTRUCTOR, 21, 1),
+    ]);
+    expect(unit.declarations, hasLength(2));
+    var extension = unit.declarations[0] as ExtensionDeclaration;
+    expect(extension.members, hasLength(0));
+  }
+
+  void test_constructor_unnamed() {
+    var unit = parseCompilationUnit('''
+extension E on C {
+  E();
+}
+class C {}
+''', errors: [
+      expectedError(ParserErrorCode.EXTENSION_DECLARES_CONSTRUCTOR, 21, 1),
+    ]);
+    expect(unit.declarations, hasLength(2));
+    var extension = unit.declarations[0] as ExtensionDeclaration;
+    expect(extension.members, hasLength(0));
+  }
+
+  void test_missing_on() {
+    var unit = parseCompilationUnit('extension E', errors: [
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 10, 1),
+      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 11, 0),
+      expectedError(ParserErrorCode.EXPECTED_BODY, 11, 0),
+    ]);
+    expect(unit.declarations, hasLength(1));
+    var extension = unit.declarations[0] as ExtensionDeclaration;
+    expect(extension.name.name, 'E');
+    expect(extension.onKeyword.lexeme, 'on');
+    expect((extension.extendedType as NamedType).name.name, '');
+    expect(extension.members, hasLength(0));
+  }
+
+  void test_missing_on_withBlock() {
+    var unit = parseCompilationUnit('extension E {}', errors: [
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 10, 1),
+      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 12, 1),
+    ]);
+    expect(unit.declarations, hasLength(1));
+    var extension = unit.declarations[0] as ExtensionDeclaration;
+    expect(extension.name.name, 'E');
+    expect(extension.onKeyword.lexeme, 'on');
+    expect((extension.extendedType as NamedType).name.name, '');
+    expect(extension.members, hasLength(0));
+  }
+
+  void test_missing_on_withClassAndBlock() {
+    var unit = parseCompilationUnit('extension E C {}', errors: [
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 10, 1),
+    ]);
+    expect(unit.declarations, hasLength(1));
+    var extension = unit.declarations[0] as ExtensionDeclaration;
+    expect(extension.name.name, 'E');
+    expect(extension.onKeyword.lexeme, 'on');
+    expect((extension.extendedType as NamedType).name.name, 'C');
+    expect(extension.members, hasLength(0));
+  }
+
+  void test_parse_toplevel_member_called_late_calling_self() {
+    CompilationUnitImpl unit = parseCompilationUnit('void late() { late(); }',
+        featureSet: nonNullable);
+    FunctionDeclaration method = unit.declarations[0];
+
+    expect(method.documentationComment, isNull);
+    expect(method.externalKeyword, isNull);
+    expect(method.propertyKeyword, isNull);
+    expect(method.returnType, isNotNull);
+    expect(method.name.name, 'late');
+    expect(method.functionExpression, isNotNull);
+
+    BlockFunctionBody body = method.functionExpression.body;
+    ExpressionStatement statement = body.block.statements[0];
+    MethodInvocation invocation = statement.expression;
+    expect(invocation.operator, isNull);
+    expect(invocation.toSource(), 'late()');
+  }
+
+  void test_simple() {
+    var unit = parseCompilationUnit('extension E on C { }');
+    expect(unit.declarations, hasLength(1));
+    var extension = unit.declarations[0] as ExtensionDeclaration;
+    expect(extension.name.name, 'E');
+    expect(extension.onKeyword.lexeme, 'on');
+    expect((extension.extendedType as NamedType).name.name, 'C');
+    var namedType = extension.extendedType as NamedType;
+    expect(namedType.name.name, 'C');
+    expect(namedType.typeArguments, isNull);
+    expect(extension.members, hasLength(0));
+  }
+
+  void test_simple_extends() {
+    var unit = parseCompilationUnit('extension E extends C { }', errors: [
+      expectedError(ParserErrorCode.EXPECTED_INSTEAD, 12, 7),
+    ]);
+    expect(unit.declarations, hasLength(1));
+    var extension = unit.declarations[0] as ExtensionDeclaration;
+    expect(extension.name.name, 'E');
+    expect(extension.onKeyword.lexeme, 'extends');
+    expect((extension.extendedType as NamedType).name.name, 'C');
+    expect(extension.members, hasLength(0));
+  }
+
+  void test_simple_implements() {
+    var unit = parseCompilationUnit('extension E implements C { }', errors: [
+      expectedError(ParserErrorCode.EXPECTED_INSTEAD, 12, 10),
+    ]);
+    expect(unit.declarations, hasLength(1));
+    var extension = unit.declarations[0] as ExtensionDeclaration;
+    expect(extension.name.name, 'E');
+    expect(extension.onKeyword.lexeme, 'implements');
+    expect((extension.extendedType as NamedType).name.name, 'C');
+    expect(extension.members, hasLength(0));
+  }
+
+  void test_simple_no_name() {
+    var unit = parseCompilationUnit('extension on C { }');
+    expect(unit.declarations, hasLength(1));
+    var extension = unit.declarations[0] as ExtensionDeclaration;
+    expect(extension.name, isNull);
+    expect(extension.onKeyword.lexeme, 'on');
+    expect((extension.extendedType as NamedType).name.name, 'C');
+    var namedType = extension.extendedType as NamedType;
+    expect(namedType.name.name, 'C');
+    expect(namedType.typeArguments, isNull);
+    expect(extension.members, hasLength(0));
+  }
+
+  void test_simple_not_enabled() {
+    parseCompilationUnit(
+      'extension E on C { }',
+      errors: [
+        expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 0, 9),
+        expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 15, 1)
+      ],
+      featureSet: FeatureSet.fromEnableFlags2(
+        sdkLanguageVersion: Version.parse('2.3.0'),
+        flags: [],
+      ),
+    );
+  }
+
+  void test_simple_with() {
+    var unit = parseCompilationUnit('extension E with C { }', errors: [
+      expectedError(ParserErrorCode.EXPECTED_INSTEAD, 12, 4),
+    ]);
+    expect(unit.declarations, hasLength(1));
+    var extension = unit.declarations[0] as ExtensionDeclaration;
+    expect(extension.name.name, 'E');
+    expect(extension.onKeyword.lexeme, 'with');
+    expect((extension.extendedType as NamedType).name.name, 'C');
+    expect(extension.members, hasLength(0));
+  }
+
+  void test_void_type() {
+    var unit = parseCompilationUnit('extension E on void { }');
+    expect(unit.declarations, hasLength(1));
+    var extension = unit.declarations[0] as ExtensionDeclaration;
+    expect(extension.name.name, 'E');
+    expect(extension.onKeyword.lexeme, 'on');
+    expect((extension.extendedType as NamedType).name.name, 'void');
+    expect(extension.members, hasLength(0));
+  }
+}
diff --git a/pkg/analyzer/test/generated/formal_parameter_parser_test.dart b/pkg/analyzer/test/generated/formal_parameter_parser_test.dart
new file mode 100644
index 0000000..da72d4b
--- /dev/null
+++ b/pkg/analyzer/test/generated/formal_parameter_parser_test.dart
@@ -0,0 +1,1425 @@
+// Copyright (c) 2020, 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.
+
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/scanner/scanner.dart';
+import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
+import 'package:analyzer/src/generated/utilities_dart.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../util/ast_type_matchers.dart';
+import 'parser_test_base.dart';
+import 'test_support.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(FormalParameterParserTest);
+  });
+}
+
+/// The class [FormalParameterParserTest] defines parser tests that test
+/// the parsing of formal parameters.
+@reflectiveTest
+class FormalParameterParserTest extends FastaParserTestCase {
+  FormalParameter parseNNBDFormalParameter(String code, ParameterKind kind,
+      {List<ExpectedError> errors}) {
+    String parametersCode;
+    if (kind == ParameterKind.REQUIRED) {
+      parametersCode = '($code)';
+    } else if (kind == ParameterKind.POSITIONAL) {
+      parametersCode = '([$code])';
+    } else if (kind == ParameterKind.NAMED) {
+      parametersCode = '({$code})';
+    } else {
+      fail('$kind');
+    }
+    createParser(parametersCode, featureSet: nonNullable);
+    FormalParameterList list =
+        parserProxy.parseFormalParameterList(inFunctionType: false);
+    assertErrors(errors: errors);
+    return list.parameters.single;
+  }
+
+  void test_fieldFormalParameter_function_nullable() {
+    var parameter =
+        parseNNBDFormalParameter('void this.a()?', ParameterKind.REQUIRED);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isFieldFormalParameter);
+    FieldFormalParameter functionParameter = parameter;
+    expect(functionParameter.type, isNotNull);
+    expect(functionParameter.identifier, isNotNull);
+    expect(functionParameter.typeParameters, isNull);
+    expect(functionParameter.parameters, isNotNull);
+    expect(functionParameter.question, isNotNull);
+    expect(functionParameter.endToken, functionParameter.question);
+  }
+
+  void test_functionTyped_named_nullable() {
+    ParameterKind kind = ParameterKind.NAMED;
+    var defaultParameter =
+        parseNNBDFormalParameter('a()? : null', kind) as DefaultFormalParameter;
+    var functionParameter =
+        defaultParameter.parameter as FunctionTypedFormalParameter;
+    assertNoErrors();
+    expect(functionParameter.returnType, isNull);
+    expect(functionParameter.identifier, isNotNull);
+    expect(functionParameter.typeParameters, isNull);
+    expect(functionParameter.parameters, isNotNull);
+    expect(functionParameter.isNamed, isTrue);
+    expect(functionParameter.question, isNotNull);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isNamed, isTrue);
+  }
+
+  void test_functionTyped_named_nullable_disabled() {
+    ParameterKind kind = ParameterKind.NAMED;
+    var defaultParameter = parseFormalParameter('a()? : null', kind,
+            featureSet: preNonNullable,
+            errorCodes: [ParserErrorCode.EXPERIMENT_NOT_ENABLED])
+        as DefaultFormalParameter;
+    var functionParameter =
+        defaultParameter.parameter as FunctionTypedFormalParameter;
+    expect(functionParameter.returnType, isNull);
+    expect(functionParameter.identifier, isNotNull);
+    expect(functionParameter.typeParameters, isNull);
+    expect(functionParameter.parameters, isNotNull);
+    expect(functionParameter.isNamed, isTrue);
+    expect(functionParameter.question, isNotNull);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isNamed, isTrue);
+  }
+
+  void test_functionTyped_positional_nullable_disabled() {
+    ParameterKind kind = ParameterKind.POSITIONAL;
+    var defaultParameter = parseFormalParameter('a()? = null', kind,
+            featureSet: preNonNullable,
+            errorCodes: [ParserErrorCode.EXPERIMENT_NOT_ENABLED])
+        as DefaultFormalParameter;
+    var functionParameter =
+        defaultParameter.parameter as FunctionTypedFormalParameter;
+    expect(functionParameter.returnType, isNull);
+    expect(functionParameter.identifier, isNotNull);
+    expect(functionParameter.typeParameters, isNull);
+    expect(functionParameter.parameters, isNotNull);
+    expect(functionParameter.isOptionalPositional, isTrue);
+    expect(functionParameter.question, isNotNull);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isOptionalPositional, isTrue);
+  }
+
+  void test_functionTyped_required_nullable_disabled() {
+    ParameterKind kind = ParameterKind.REQUIRED;
+    var functionParameter = parseFormalParameter('a()?', kind,
+            featureSet: preNonNullable,
+            errorCodes: [ParserErrorCode.EXPERIMENT_NOT_ENABLED])
+        as FunctionTypedFormalParameter;
+    expect(functionParameter.returnType, isNull);
+    expect(functionParameter.identifier, isNotNull);
+    expect(functionParameter.typeParameters, isNull);
+    expect(functionParameter.parameters, isNotNull);
+    expect(functionParameter.isRequiredPositional, isTrue);
+    expect(functionParameter.question, isNotNull);
+  }
+
+  void test_parseConstructorParameter_this() {
+    parseCompilationUnit('''
+class C {
+  final int field;
+  C(this.field);
+}''');
+  }
+
+  void test_parseConstructorParameter_this_Function() {
+    parseCompilationUnit('''
+class C {
+  final Object Function(int, double) field;
+  C(String Function(num, Object) this.field);
+}''');
+  }
+
+  void test_parseConstructorParameter_this_int() {
+    parseCompilationUnit('''
+class C {
+  final int field;
+  C(int this.field);
+}''');
+  }
+
+  void test_parseFormalParameter_covariant_final_named() {
+    ParameterKind kind = ParameterKind.NAMED;
+    FormalParameter parameter =
+        parseFormalParameter('covariant final a : null', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNotNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.isNamed, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isNamed, isTrue);
+  }
+
+  void test_parseFormalParameter_covariant_final_normal() {
+    ParameterKind kind = ParameterKind.REQUIRED;
+    FormalParameter parameter = parseFormalParameter('covariant final a', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isSimpleFormalParameter);
+    SimpleFormalParameter simpleParameter = parameter;
+    expect(simpleParameter.covariantKeyword, isNotNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.isRequired, isTrue);
+  }
+
+  void test_parseFormalParameter_covariant_final_positional() {
+    ParameterKind kind = ParameterKind.POSITIONAL;
+    FormalParameter parameter =
+        parseFormalParameter('covariant final a = null', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNotNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.isOptionalPositional, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isOptionalPositional, isTrue);
+  }
+
+  void test_parseFormalParameter_covariant_final_type_named() {
+    ParameterKind kind = ParameterKind.NAMED;
+    FormalParameter parameter =
+        parseFormalParameter('covariant final A a : null', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNotNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.isNamed, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isNamed, isTrue);
+  }
+
+  void test_parseFormalParameter_covariant_final_type_normal() {
+    ParameterKind kind = ParameterKind.REQUIRED;
+    FormalParameter parameter =
+        parseFormalParameter('covariant final A a', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isSimpleFormalParameter);
+    SimpleFormalParameter simpleParameter = parameter;
+    expect(simpleParameter.covariantKeyword, isNotNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.isRequired, isTrue);
+  }
+
+  void test_parseFormalParameter_covariant_final_type_positional() {
+    ParameterKind kind = ParameterKind.POSITIONAL;
+    FormalParameter parameter =
+        parseFormalParameter('covariant final A a = null', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNotNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.isOptionalPositional, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isOptionalPositional, isTrue);
+  }
+
+  void test_parseFormalParameter_covariant_required_named() {
+    ParameterKind kind = ParameterKind.NAMED;
+    FormalParameter parameter = parseNNBDFormalParameter(
+        'covariant required A a : null', kind,
+        errors: [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 12, 8)]);
+    expect(parameter, isNotNull);
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNotNull);
+    expect(simpleParameter.requiredKeyword, isNotNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.isNamed, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isNamed, isTrue);
+  }
+
+  void test_parseFormalParameter_covariant_type_function() {
+    ParameterKind kind = ParameterKind.REQUIRED;
+    FormalParameter parameter =
+        parseFormalParameter('covariant String Function(int) a', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isSimpleFormalParameter);
+    SimpleFormalParameter simpleParameter = parameter;
+    expect(simpleParameter.covariantKeyword, isNotNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNull);
+    expect(simpleParameter.type, isGenericFunctionType);
+    expect(simpleParameter.isRequired, isTrue);
+  }
+
+  void test_parseFormalParameter_covariant_type_named() {
+    ParameterKind kind = ParameterKind.NAMED;
+    FormalParameter parameter =
+        parseFormalParameter('covariant A a : null', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNotNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.isNamed, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isNamed, isTrue);
+  }
+
+  void test_parseFormalParameter_covariant_type_normal() {
+    ParameterKind kind = ParameterKind.REQUIRED;
+    FormalParameter parameter =
+        parseFormalParameter('covariant A<B<C>> a', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isSimpleFormalParameter);
+    SimpleFormalParameter simpleParameter = parameter;
+    expect(simpleParameter.covariantKeyword, isNotNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.isRequired, isTrue);
+  }
+
+  void test_parseFormalParameter_covariant_type_positional() {
+    ParameterKind kind = ParameterKind.POSITIONAL;
+    FormalParameter parameter =
+        parseFormalParameter('covariant A a = null', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNotNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.isOptionalPositional, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isOptionalPositional, isTrue);
+  }
+
+  void test_parseFormalParameter_covariant_var_named() {
+    ParameterKind kind = ParameterKind.NAMED;
+    FormalParameter parameter =
+        parseFormalParameter('covariant var a : null', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNotNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.isNamed, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isNamed, isTrue);
+  }
+
+  void test_parseFormalParameter_covariant_var_normal() {
+    ParameterKind kind = ParameterKind.REQUIRED;
+    FormalParameter parameter = parseFormalParameter('covariant var a', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isSimpleFormalParameter);
+    SimpleFormalParameter simpleParameter = parameter;
+    expect(simpleParameter.covariantKeyword, isNotNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.isRequired, isTrue);
+  }
+
+  void test_parseFormalParameter_covariant_var_positional() {
+    ParameterKind kind = ParameterKind.POSITIONAL;
+    FormalParameter parameter =
+        parseFormalParameter('covariant var a = null', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNotNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.isOptionalPositional, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isOptionalPositional, isTrue);
+  }
+
+  void test_parseFormalParameter_external() {
+    parseNNBDFormalParameter('external int i', ParameterKind.REQUIRED, errors: [
+      expectedError(ParserErrorCode.EXTRANEOUS_MODIFIER, 1, 8),
+    ]);
+  }
+
+  void test_parseFormalParameter_final_named() {
+    ParameterKind kind = ParameterKind.NAMED;
+    FormalParameter parameter = parseFormalParameter('final a : null', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.isNamed, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isNamed, isTrue);
+  }
+
+  void test_parseFormalParameter_final_normal() {
+    ParameterKind kind = ParameterKind.REQUIRED;
+    FormalParameter parameter = parseFormalParameter('final a', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isSimpleFormalParameter);
+    SimpleFormalParameter simpleParameter = parameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.isRequired, isTrue);
+  }
+
+  void test_parseFormalParameter_final_positional() {
+    ParameterKind kind = ParameterKind.POSITIONAL;
+    FormalParameter parameter = parseFormalParameter('final a = null', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.isOptionalPositional, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isOptionalPositional, isTrue);
+  }
+
+  void test_parseFormalParameter_final_required_named() {
+    ParameterKind kind = ParameterKind.NAMED;
+    FormalParameter parameter = parseNNBDFormalParameter(
+        'final required a : null', kind,
+        errors: [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 8, 8)]);
+    expect(parameter, isNotNull);
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.requiredKeyword, isNotNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.isNamed, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isNamed, isTrue);
+  }
+
+  void test_parseFormalParameter_final_type_named() {
+    ParameterKind kind = ParameterKind.NAMED;
+    FormalParameter parameter = parseFormalParameter('final A a : null', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.isNamed, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isNamed, isTrue);
+  }
+
+  void test_parseFormalParameter_final_type_normal() {
+    ParameterKind kind = ParameterKind.REQUIRED;
+    FormalParameter parameter = parseFormalParameter('final A a', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isSimpleFormalParameter);
+    SimpleFormalParameter simpleParameter = parameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.isRequired, isTrue);
+  }
+
+  void test_parseFormalParameter_final_type_positional() {
+    ParameterKind kind = ParameterKind.POSITIONAL;
+    FormalParameter parameter = parseFormalParameter('final A a = null', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.isOptionalPositional, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isOptionalPositional, isTrue);
+  }
+
+  void test_parseFormalParameter_required_covariant_named() {
+    ParameterKind kind = ParameterKind.NAMED;
+    FormalParameter parameter =
+        parseNNBDFormalParameter('required covariant A a : null', kind);
+    expect(parameter, isNotNull);
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNotNull);
+    expect(simpleParameter.requiredKeyword, isNotNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.isNamed, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isNamed, isTrue);
+  }
+
+  void test_parseFormalParameter_required_final_named() {
+    ParameterKind kind = ParameterKind.NAMED;
+    FormalParameter parameter =
+        parseNNBDFormalParameter('required final a : null', kind);
+    expect(parameter, isNotNull);
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.requiredKeyword, isNotNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.isNamed, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isNamed, isTrue);
+  }
+
+  void test_parseFormalParameter_required_type_named() {
+    ParameterKind kind = ParameterKind.NAMED;
+    FormalParameter parameter =
+        parseNNBDFormalParameter('required A a : null', kind);
+    expect(parameter, isNotNull);
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.requiredKeyword, isNotNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.isNamed, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isNamed, isTrue);
+  }
+
+  void test_parseFormalParameter_required_var_named() {
+    ParameterKind kind = ParameterKind.NAMED;
+    FormalParameter parameter =
+        parseNNBDFormalParameter('required var a : null', kind);
+    expect(parameter, isNotNull);
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.requiredKeyword, isNotNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.isNamed, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isNamed, isTrue);
+  }
+
+  void test_parseFormalParameter_type_function() {
+    ParameterKind kind = ParameterKind.REQUIRED;
+    FormalParameter parameter =
+        parseFormalParameter('String Function(int) a', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isSimpleFormalParameter);
+    SimpleFormalParameter simpleParameter = parameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNull);
+    expect(simpleParameter.type, isGenericFunctionType);
+    expect(simpleParameter.isRequired, isTrue);
+  }
+
+  void test_parseFormalParameter_type_named() {
+    ParameterKind kind = ParameterKind.NAMED;
+    FormalParameter parameter = parseFormalParameter('A a : null', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.isNamed, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isNamed, isTrue);
+  }
+
+  void test_parseFormalParameter_type_named_noDefault() {
+    ParameterKind kind = ParameterKind.NAMED;
+    FormalParameter parameter = parseFormalParameter('A a', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.isNamed, isTrue);
+    expect(defaultParameter.separator, isNull);
+    expect(defaultParameter.defaultValue, isNull);
+    expect(defaultParameter.isNamed, isTrue);
+  }
+
+  void test_parseFormalParameter_type_normal() {
+    ParameterKind kind = ParameterKind.REQUIRED;
+    FormalParameter parameter = parseFormalParameter('A a', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isSimpleFormalParameter);
+    SimpleFormalParameter simpleParameter = parameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.isRequired, isTrue);
+  }
+
+  void test_parseFormalParameter_type_positional() {
+    ParameterKind kind = ParameterKind.POSITIONAL;
+    FormalParameter parameter = parseFormalParameter('A a = null', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.isOptionalPositional, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isOptionalPositional, isTrue);
+  }
+
+  void test_parseFormalParameter_type_positional_noDefault() {
+    ParameterKind kind = ParameterKind.POSITIONAL;
+    FormalParameter parameter = parseFormalParameter('A a', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.isOptionalPositional, isTrue);
+    expect(defaultParameter.separator, isNull);
+    expect(defaultParameter.defaultValue, isNull);
+    expect(defaultParameter.isOptionalPositional, isTrue);
+  }
+
+  void test_parseFormalParameter_var_named() {
+    ParameterKind kind = ParameterKind.NAMED;
+    FormalParameter parameter = parseFormalParameter('var a : null', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.isNamed, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isNamed, isTrue);
+  }
+
+  void test_parseFormalParameter_var_normal() {
+    ParameterKind kind = ParameterKind.REQUIRED;
+    FormalParameter parameter = parseFormalParameter('var a', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isSimpleFormalParameter);
+    SimpleFormalParameter simpleParameter = parameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.isRequired, isTrue);
+  }
+
+  void test_parseFormalParameter_var_positional() {
+    ParameterKind kind = ParameterKind.POSITIONAL;
+    FormalParameter parameter = parseFormalParameter('var a = null', kind);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.requiredKeyword, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.isOptionalPositional, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isOptionalPositional, isTrue);
+  }
+
+  void test_parseFormalParameter_var_required_named() {
+    ParameterKind kind = ParameterKind.NAMED;
+    FormalParameter parameter = parseNNBDFormalParameter(
+        'var required a : null', kind,
+        errors: [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 6, 8)]);
+    expect(parameter, isNotNull);
+    expect(parameter, isDefaultFormalParameter);
+    DefaultFormalParameter defaultParameter = parameter;
+    SimpleFormalParameter simpleParameter =
+        defaultParameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.requiredKeyword, isNotNull);
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.isNamed, isTrue);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isNamed, isTrue);
+  }
+
+  void test_parseFormalParameterList_empty() {
+    FormalParameterList list = parseFormalParameterList('()');
+    expect(list, isNotNull);
+    assertNoErrors();
+    expect(list.leftParenthesis, isNotNull);
+    expect(list.leftDelimiter, isNull);
+    expect(list.parameters, hasLength(0));
+    expect(list.rightDelimiter, isNull);
+    expect(list.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_named_multiple() {
+    FormalParameterList list =
+        parseFormalParameterList('({A a : 1, B b, C c : 3})');
+    expect(list, isNotNull);
+    assertNoErrors();
+    expect(list.leftParenthesis, isNotNull);
+    expect(list.leftDelimiter, isNotNull);
+    expect(list.parameters, hasLength(3));
+    expect(list.rightDelimiter, isNotNull);
+    expect(list.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_named_single() {
+    FormalParameterList list = parseFormalParameterList('({A a})');
+    expect(list, isNotNull);
+    assertNoErrors();
+    expect(list.leftParenthesis, isNotNull);
+    expect(list.leftDelimiter, isNotNull);
+    expect(list.parameters, hasLength(1));
+    expect(list.rightDelimiter, isNotNull);
+    expect(list.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_named_trailing_comma() {
+    FormalParameterList list = parseFormalParameterList('(A a, {B b,})');
+    expect(list, isNotNull);
+    assertNoErrors();
+    expect(list.leftParenthesis, isNotNull);
+    expect(list.leftDelimiter, isNotNull);
+    expect(list.parameters, hasLength(2));
+    expect(list.rightDelimiter, isNotNull);
+    expect(list.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_normal_multiple() {
+    FormalParameterList list = parseFormalParameterList('(A a, B b, C c)');
+    expect(list, isNotNull);
+    assertNoErrors();
+    expect(list.leftParenthesis, isNotNull);
+    expect(list.leftDelimiter, isNull);
+    expect(list.parameters, hasLength(3));
+    expect(list.rightDelimiter, isNull);
+    expect(list.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_normal_named() {
+    FormalParameterList list = parseFormalParameterList('(A a, {B b})');
+    expect(list, isNotNull);
+    assertNoErrors();
+    expect(list.leftParenthesis, isNotNull);
+    expect(list.leftDelimiter, isNotNull);
+    expect(list.parameters, hasLength(2));
+    expect(list.rightDelimiter, isNotNull);
+    expect(list.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_normal_named_inFunctionType() {
+    FormalParameterList list =
+        parseFormalParameterList('(A, {B b})', inFunctionType: true);
+    expect(list, isNotNull);
+    assertNoErrors();
+    expect(list.leftParenthesis, isNotNull);
+    expect(list.leftDelimiter, isNotNull);
+    expect(list.rightDelimiter, isNotNull);
+    expect(list.rightParenthesis, isNotNull);
+    NodeList<FormalParameter> parameters = list.parameters;
+    expect(parameters, hasLength(2));
+
+    expect(parameters[0], isSimpleFormalParameter);
+    SimpleFormalParameter required = parameters[0];
+    expect(required.identifier, isNull);
+    expect(required.type, isTypeName);
+    expect((required.type as TypeName).name.name, 'A');
+
+    expect(parameters[1], isDefaultFormalParameter);
+    DefaultFormalParameter named = parameters[1];
+    expect(named.identifier, isNotNull);
+    expect(named.parameter, isSimpleFormalParameter);
+    SimpleFormalParameter simple = named.parameter;
+    expect(simple.type, isTypeName);
+    expect((simple.type as TypeName).name.name, 'B');
+  }
+
+  void test_parseFormalParameterList_normal_positional() {
+    FormalParameterList list = parseFormalParameterList('(A a, [B b])');
+    expect(list, isNotNull);
+    assertNoErrors();
+    expect(list.leftParenthesis, isNotNull);
+    expect(list.leftDelimiter, isNotNull);
+    expect(list.parameters, hasLength(2));
+    expect(list.rightDelimiter, isNotNull);
+    expect(list.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_normal_single() {
+    FormalParameterList list = parseFormalParameterList('(A a)');
+    expect(list, isNotNull);
+    assertNoErrors();
+    expect(list.leftParenthesis, isNotNull);
+    expect(list.leftDelimiter, isNull);
+    expect(list.parameters, hasLength(1));
+    expect(list.rightDelimiter, isNull);
+    expect(list.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_normal_single_Function() {
+    FormalParameterList list = parseFormalParameterList('(Function f)');
+    expect(list, isNotNull);
+    assertNoErrors();
+    expect(list.leftParenthesis, isNotNull);
+    expect(list.leftDelimiter, isNull);
+    expect(list.parameters, hasLength(1));
+    expect(list.rightDelimiter, isNull);
+    expect(list.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_normal_single_trailing_comma() {
+    FormalParameterList list = parseFormalParameterList('(A a,)');
+    expect(list, isNotNull);
+    assertNoErrors();
+    expect(list.leftParenthesis, isNotNull);
+    expect(list.leftDelimiter, isNull);
+    expect(list.parameters, hasLength(1));
+    expect(list.rightDelimiter, isNull);
+    expect(list.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_positional_multiple() {
+    FormalParameterList list =
+        parseFormalParameterList('([A a = null, B b, C c = null])');
+    expect(list, isNotNull);
+    assertNoErrors();
+    expect(list.leftParenthesis, isNotNull);
+    expect(list.leftDelimiter, isNotNull);
+    expect(list.parameters, hasLength(3));
+    expect(list.rightDelimiter, isNotNull);
+    expect(list.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_positional_single() {
+    FormalParameterList list = parseFormalParameterList('([A a = null])');
+    expect(list, isNotNull);
+    assertNoErrors();
+    expect(list.leftParenthesis, isNotNull);
+    expect(list.leftDelimiter, isNotNull);
+    expect(list.parameters, hasLength(1));
+    expect(list.rightDelimiter, isNotNull);
+    expect(list.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_positional_trailing_comma() {
+    FormalParameterList list = parseFormalParameterList('(A a, [B b,])');
+    expect(list, isNotNull);
+    assertNoErrors();
+    expect(list.leftParenthesis, isNotNull);
+    expect(list.leftDelimiter, isNotNull);
+    expect(list.parameters, hasLength(2));
+    expect(list.rightDelimiter, isNotNull);
+    expect(list.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_prefixedType() {
+    FormalParameterList list = parseFormalParameterList('(io.File f)');
+    expect(list, isNotNull);
+    assertNoErrors();
+    expect(list.leftParenthesis, isNotNull);
+    expect(list.leftDelimiter, isNull);
+    expect(list.parameters, hasLength(1));
+    expect(list.parameters[0].toSource(), 'io.File f');
+    expect(list.rightDelimiter, isNull);
+    expect(list.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_prefixedType_missingName() {
+    FormalParameterList list = parseFormalParameterList('(io.File)',
+        errors: [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 1)]);
+    expect(list, isNotNull);
+    expect(list.leftParenthesis, isNotNull);
+    expect(list.leftDelimiter, isNull);
+    expect(list.parameters, hasLength(1));
+    // TODO(danrubel): Investigate and improve recovery of parameter type/name.
+    SimpleFormalParameter parameter = list.parameters[0];
+    expect(parameter.toSource(), 'io.File ');
+    expect(parameter.identifier.token.isSynthetic, isTrue);
+    TypeName type = parameter.type;
+    PrefixedIdentifier typeName = type.name;
+    expect(typeName.prefix.token.isSynthetic, isFalse);
+    expect(typeName.identifier.token.isSynthetic, isFalse);
+    expect(list.rightDelimiter, isNull);
+    expect(list.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_prefixedType_partial() {
+    FormalParameterList list = parseFormalParameterList('(io.)', errors: [
+      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 4, 1),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 4, 1)
+    ]);
+    expect(list, isNotNull);
+    expect(list.leftParenthesis, isNotNull);
+    expect(list.leftDelimiter, isNull);
+    expect(list.parameters, hasLength(1));
+    // TODO(danrubel): Investigate and improve recovery of parameter type/name.
+    SimpleFormalParameter parameter = list.parameters[0];
+    expect(parameter.toSource(), 'io. ');
+    expect(parameter.identifier.token.isSynthetic, isTrue);
+    TypeName type = parameter.type;
+    PrefixedIdentifier typeName = type.name;
+    expect(typeName.prefix.token.isSynthetic, isFalse);
+    expect(typeName.identifier.token.isSynthetic, isTrue);
+    expect(list.rightDelimiter, isNull);
+    expect(list.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_prefixedType_partial2() {
+    FormalParameterList list = parseFormalParameterList('(io.,a)', errors: [
+      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 4, 1),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 4, 1)
+    ]);
+    expect(list, isNotNull);
+    expect(list.leftParenthesis, isNotNull);
+    expect(list.leftDelimiter, isNull);
+    expect(list.parameters, hasLength(2));
+    expect(list.parameters[0].toSource(), 'io. ');
+    expect(list.parameters[1].toSource(), 'a');
+    expect(list.rightDelimiter, isNull);
+    expect(list.rightParenthesis, isNotNull);
+  }
+
+  void test_parseNormalFormalParameter_field_const_noType() {
+    NormalFormalParameter parameter = parseNormalFormalParameter('const this.a',
+        errorCodes: [ParserErrorCode.EXTRANEOUS_MODIFIER]);
+    expect(parameter, isNotNull);
+    expect(parameter, isFieldFormalParameter);
+    FieldFormalParameter fieldParameter = parameter;
+    expect(fieldParameter.keyword, isNotNull);
+    expect(fieldParameter.type, isNull);
+    expect(fieldParameter.identifier, isNotNull);
+    expect(fieldParameter.parameters, isNull);
+  }
+
+  void test_parseNormalFormalParameter_field_const_type() {
+    NormalFormalParameter parameter = parseNormalFormalParameter(
+        'const A this.a',
+        errorCodes: [ParserErrorCode.EXTRANEOUS_MODIFIER]);
+    expect(parameter, isNotNull);
+    expect(parameter, isFieldFormalParameter);
+    FieldFormalParameter fieldParameter = parameter;
+    expect(fieldParameter.keyword, isNotNull);
+    expect(fieldParameter.type, isNotNull);
+    expect(fieldParameter.identifier, isNotNull);
+    expect(fieldParameter.parameters, isNull);
+  }
+
+  void test_parseNormalFormalParameter_field_final_noType() {
+    NormalFormalParameter parameter =
+        parseNormalFormalParameter('final this.a');
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isFieldFormalParameter);
+    FieldFormalParameter fieldParameter = parameter;
+    expect(fieldParameter.keyword, isNotNull);
+    expect(fieldParameter.type, isNull);
+    expect(fieldParameter.identifier, isNotNull);
+    expect(fieldParameter.parameters, isNull);
+  }
+
+  void test_parseNormalFormalParameter_field_final_type() {
+    NormalFormalParameter parameter =
+        parseNormalFormalParameter('final A this.a');
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isFieldFormalParameter);
+    FieldFormalParameter fieldParameter = parameter;
+    expect(fieldParameter.keyword, isNotNull);
+    expect(fieldParameter.type, isNotNull);
+    expect(fieldParameter.identifier, isNotNull);
+    expect(fieldParameter.parameters, isNull);
+  }
+
+  void test_parseNormalFormalParameter_field_function_nested() {
+    NormalFormalParameter parameter = parseNormalFormalParameter('this.a(B b)');
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isFieldFormalParameter);
+    FieldFormalParameter fieldParameter = parameter;
+    expect(fieldParameter.keyword, isNull);
+    expect(fieldParameter.type, isNull);
+    expect(fieldParameter.identifier, isNotNull);
+    FormalParameterList parameterList = fieldParameter.parameters;
+    expect(parameterList, isNotNull);
+    expect(parameterList.parameters, hasLength(1));
+  }
+
+  void test_parseNormalFormalParameter_field_function_noNested() {
+    NormalFormalParameter parameter = parseNormalFormalParameter('this.a()');
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isFieldFormalParameter);
+    FieldFormalParameter fieldParameter = parameter;
+    expect(fieldParameter.keyword, isNull);
+    expect(fieldParameter.type, isNull);
+    expect(fieldParameter.identifier, isNotNull);
+    FormalParameterList parameterList = fieldParameter.parameters;
+    expect(parameterList, isNotNull);
+    expect(parameterList.parameters, hasLength(0));
+  }
+
+  void test_parseNormalFormalParameter_field_function_withDocComment() {
+    var parameter = parseNormalFormalParameter('/// Doc\nthis.f()');
+    expectCommentText(parameter.documentationComment, '/// Doc');
+  }
+
+  void test_parseNormalFormalParameter_field_noType() {
+    NormalFormalParameter parameter = parseNormalFormalParameter('this.a');
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isFieldFormalParameter);
+    FieldFormalParameter fieldParameter = parameter;
+    expect(fieldParameter.keyword, isNull);
+    expect(fieldParameter.type, isNull);
+    expect(fieldParameter.identifier, isNotNull);
+    expect(fieldParameter.parameters, isNull);
+  }
+
+  void test_parseNormalFormalParameter_field_type() {
+    NormalFormalParameter parameter = parseNormalFormalParameter('A this.a');
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isFieldFormalParameter);
+    FieldFormalParameter fieldParameter = parameter;
+    expect(fieldParameter.keyword, isNull);
+    expect(fieldParameter.type, isNotNull);
+    expect(fieldParameter.identifier, isNotNull);
+    expect(fieldParameter.parameters, isNull);
+  }
+
+  void test_parseNormalFormalParameter_field_var() {
+    NormalFormalParameter parameter = parseNormalFormalParameter('var this.a');
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isFieldFormalParameter);
+    FieldFormalParameter fieldParameter = parameter;
+    expect(fieldParameter.keyword, isNotNull);
+    expect(fieldParameter.type, isNull);
+    expect(fieldParameter.identifier, isNotNull);
+    expect(fieldParameter.parameters, isNull);
+  }
+
+  void test_parseNormalFormalParameter_field_withDocComment() {
+    var parameter = parseNormalFormalParameter('/// Doc\nthis.a');
+    expectCommentText(parameter.documentationComment, '/// Doc');
+  }
+
+  void test_parseNormalFormalParameter_function_named() {
+    ParameterKind kind = ParameterKind.NAMED;
+    var defaultParameter =
+        parseFormalParameter('a() : null', kind) as DefaultFormalParameter;
+    var functionParameter =
+        defaultParameter.parameter as FunctionTypedFormalParameter;
+    assertNoErrors();
+    expect(functionParameter.returnType, isNull);
+    expect(functionParameter.identifier, isNotNull);
+    expect(functionParameter.typeParameters, isNull);
+    expect(functionParameter.parameters, isNotNull);
+    expect(functionParameter.isNamed, isTrue);
+    expect(functionParameter.question, isNull);
+    expect(defaultParameter.separator, isNotNull);
+    expect(defaultParameter.defaultValue, isNotNull);
+    expect(defaultParameter.isNamed, isTrue);
+  }
+
+  void test_parseNormalFormalParameter_function_noType() {
+    NormalFormalParameter parameter = parseNormalFormalParameter('a()');
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isFunctionTypedFormalParameter);
+    FunctionTypedFormalParameter functionParameter = parameter;
+    expect(functionParameter.returnType, isNull);
+    expect(functionParameter.identifier, isNotNull);
+    expect(functionParameter.typeParameters, isNull);
+    expect(functionParameter.parameters, isNotNull);
+    expect(functionParameter.question, isNull);
+  }
+
+  void test_parseNormalFormalParameter_function_noType_covariant() {
+    NormalFormalParameter parameter =
+        parseNormalFormalParameter('covariant a()');
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isFunctionTypedFormalParameter);
+    FunctionTypedFormalParameter functionParameter = parameter;
+    expect(functionParameter.covariantKeyword, isNotNull);
+    expect(functionParameter.returnType, isNull);
+    expect(functionParameter.identifier, isNotNull);
+    expect(functionParameter.typeParameters, isNull);
+    expect(functionParameter.parameters, isNotNull);
+    expect(functionParameter.question, isNull);
+  }
+
+  void test_parseNormalFormalParameter_function_noType_nullable() {
+    NormalFormalParameter parameter =
+        parseNNBDFormalParameter('a()?', ParameterKind.REQUIRED);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isFunctionTypedFormalParameter);
+    FunctionTypedFormalParameter functionParameter = parameter;
+    expect(functionParameter.returnType, isNull);
+    expect(functionParameter.identifier, isNotNull);
+    expect(functionParameter.typeParameters, isNull);
+    expect(functionParameter.parameters, isNotNull);
+    expect(functionParameter.question, isNotNull);
+    expect(functionParameter.endToken, functionParameter.question);
+  }
+
+  void test_parseNormalFormalParameter_function_noType_typeParameters() {
+    NormalFormalParameter parameter = parseNormalFormalParameter('a<E>()');
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isFunctionTypedFormalParameter);
+    FunctionTypedFormalParameter functionParameter = parameter;
+    expect(functionParameter.returnType, isNull);
+    expect(functionParameter.identifier, isNotNull);
+    expect(functionParameter.typeParameters, isNotNull);
+    expect(functionParameter.parameters, isNotNull);
+    expect(functionParameter.question, isNull);
+  }
+
+  void test_parseNormalFormalParameter_function_type() {
+    NormalFormalParameter parameter = parseNormalFormalParameter('A a()');
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isFunctionTypedFormalParameter);
+    FunctionTypedFormalParameter functionParameter = parameter;
+    expect(functionParameter.returnType, isNotNull);
+    expect(functionParameter.identifier, isNotNull);
+    expect(functionParameter.typeParameters, isNull);
+    expect(functionParameter.parameters, isNotNull);
+    expect(functionParameter.question, isNull);
+  }
+
+  void test_parseNormalFormalParameter_function_type_typeParameters() {
+    NormalFormalParameter parameter = parseNormalFormalParameter('A a<E>()');
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isFunctionTypedFormalParameter);
+    FunctionTypedFormalParameter functionParameter = parameter;
+    expect(functionParameter.returnType, isNotNull);
+    expect(functionParameter.identifier, isNotNull);
+    expect(functionParameter.typeParameters, isNotNull);
+    expect(functionParameter.parameters, isNotNull);
+    expect(functionParameter.question, isNull);
+  }
+
+  void test_parseNormalFormalParameter_function_typeVoid_covariant() {
+    NormalFormalParameter parameter =
+        parseNormalFormalParameter('covariant void a()');
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isFunctionTypedFormalParameter);
+    FunctionTypedFormalParameter functionParameter = parameter;
+    expect(functionParameter.covariantKeyword, isNotNull);
+    expect(functionParameter.returnType, isNotNull);
+    expect(functionParameter.identifier, isNotNull);
+    expect(functionParameter.typeParameters, isNull);
+    expect(functionParameter.parameters, isNotNull);
+    expect(functionParameter.question, isNull);
+  }
+
+  void test_parseNormalFormalParameter_function_void() {
+    NormalFormalParameter parameter = parseNormalFormalParameter('void a()');
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isFunctionTypedFormalParameter);
+    FunctionTypedFormalParameter functionParameter = parameter;
+    expect(functionParameter.returnType, isNotNull);
+    expect(functionParameter.identifier, isNotNull);
+    expect(functionParameter.typeParameters, isNull);
+    expect(functionParameter.parameters, isNotNull);
+    expect(functionParameter.question, isNull);
+  }
+
+  void test_parseNormalFormalParameter_function_void_typeParameters() {
+    NormalFormalParameter parameter = parseNormalFormalParameter('void a<E>()');
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isFunctionTypedFormalParameter);
+    FunctionTypedFormalParameter functionParameter = parameter;
+    expect(functionParameter.returnType, isNotNull);
+    expect(functionParameter.identifier, isNotNull);
+    expect(functionParameter.typeParameters, isNotNull);
+    expect(functionParameter.parameters, isNotNull);
+    expect(functionParameter.question, isNull);
+  }
+
+  void test_parseNormalFormalParameter_function_withDocComment() {
+    var parameter = parseFormalParameter('/// Doc\nf()', ParameterKind.REQUIRED)
+        as FunctionTypedFormalParameter;
+    expectCommentText(parameter.documentationComment, '/// Doc');
+  }
+
+  void test_parseNormalFormalParameter_simple_const_noType() {
+    NormalFormalParameter parameter = parseNormalFormalParameter('const a',
+        errorCodes: [ParserErrorCode.EXTRANEOUS_MODIFIER]);
+    expect(parameter, isNotNull);
+    expect(parameter, isSimpleFormalParameter);
+    SimpleFormalParameter simpleParameter = parameter;
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+  }
+
+  void test_parseNormalFormalParameter_simple_const_type() {
+    NormalFormalParameter parameter = parseNormalFormalParameter('const A a',
+        errorCodes: [ParserErrorCode.EXTRANEOUS_MODIFIER]);
+    expect(parameter, isNotNull);
+    expect(parameter, isSimpleFormalParameter);
+    SimpleFormalParameter simpleParameter = parameter;
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.identifier, isNotNull);
+  }
+
+  void test_parseNormalFormalParameter_simple_final_noType() {
+    NormalFormalParameter parameter = parseNormalFormalParameter('final a');
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isSimpleFormalParameter);
+    SimpleFormalParameter simpleParameter = parameter;
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+  }
+
+  void test_parseNormalFormalParameter_simple_final_type() {
+    NormalFormalParameter parameter = parseNormalFormalParameter('final A a');
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isSimpleFormalParameter);
+    SimpleFormalParameter simpleParameter = parameter;
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.identifier, isNotNull);
+  }
+
+  void test_parseNormalFormalParameter_simple_noName() {
+    NormalFormalParameter parameter =
+        parseNormalFormalParameter('a', inFunctionType: true);
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isSimpleFormalParameter);
+    SimpleFormalParameter simpleParameter = parameter;
+    expect(simpleParameter.keyword, isNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.identifier, isNull);
+  }
+
+  void test_parseNormalFormalParameter_simple_noType() {
+    NormalFormalParameter parameter = parseNormalFormalParameter('a');
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isSimpleFormalParameter);
+    SimpleFormalParameter simpleParameter = parameter;
+    expect(simpleParameter.keyword, isNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+  }
+
+  void test_parseNormalFormalParameter_simple_noType_namedCovariant() {
+    NormalFormalParameter parameter = parseNormalFormalParameter('covariant');
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isSimpleFormalParameter);
+    SimpleFormalParameter simpleParameter = parameter;
+    expect(simpleParameter.covariantKeyword, isNull);
+    expect(simpleParameter.keyword, isNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.identifier, isNotNull);
+  }
+
+  void test_parseNormalFormalParameter_simple_type() {
+    NormalFormalParameter parameter = parseNormalFormalParameter('A a');
+    expect(parameter, isNotNull);
+    assertNoErrors();
+    expect(parameter, isSimpleFormalParameter);
+    SimpleFormalParameter simpleParameter = parameter;
+    expect(simpleParameter.keyword, isNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.identifier, isNotNull);
+  }
+}
diff --git a/pkg/analyzer/test/generated/nnbd_parser_test.dart b/pkg/analyzer/test/generated/nnbd_parser_test.dart
new file mode 100644
index 0000000..6fd7547
--- /dev/null
+++ b/pkg/analyzer/test/generated/nnbd_parser_test.dart
@@ -0,0 +1,862 @@
+// Copyright (c) 2020, 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.
+
+import 'package:analyzer/dart/analysis/features.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
+import 'package:analyzer/error/error.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/scanner/scanner.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../util/ast_type_matchers.dart';
+import 'parser_test_base.dart';
+import 'test_support.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(NNBDParserTest);
+  });
+}
+
+@reflectiveTest
+class NNBDParserTest extends FastaParserTestCase {
+  @override
+  CompilationUnit parseCompilationUnit(String content,
+          {List<ErrorCode> codes,
+          List<ExpectedError> errors,
+          FeatureSet featureSet}) =>
+      super.parseCompilationUnit(content,
+          codes: codes,
+          errors: errors,
+          featureSet: featureSet ?? FeatureSet.latestLanguageVersion());
+
+  void test_assignment_complex() {
+    parseCompilationUnit('D? foo(X? x) { X? x1; X? x2 = x + bar(7); }');
+  }
+
+  void test_assignment_complex2() {
+    parseCompilationUnit(r'''
+main() {
+  A? a;
+  String? s = '';
+  a?..foo().length..x27 = s!..toString().length;
+}
+''');
+  }
+
+  void test_assignment_simple() {
+    parseCompilationUnit('D? foo(X? x) { X? x1; X? x2 = x; }');
+  }
+
+  void test_bangBeforeFuctionCall1() {
+    // https://github.com/dart-lang/sdk/issues/39776
+    var unit = parseCompilationUnit('f() { Function? f1; f1!(42); }');
+    var funct = unit.declarations[0] as FunctionDeclaration;
+    var body = funct.functionExpression.body as BlockFunctionBody;
+    var statement1 = body.block.statements[0] as VariableDeclarationStatement;
+    expect(statement1.toSource(), "Function? f1;");
+    var statement2 = body.block.statements[1] as ExpressionStatement;
+
+    // expression is "f1!(42)"
+    var expression = statement2.expression as FunctionExpressionInvocation;
+    expect(expression.toSource(), "f1!(42)");
+
+    var functionExpression = expression.function as PostfixExpression;
+    SimpleIdentifier identifier = functionExpression.operand;
+    expect(identifier.name, 'f1');
+    expect(functionExpression.operator.lexeme, '!');
+
+    expect(expression.typeArguments, null);
+
+    expect(expression.argumentList.arguments.length, 1);
+    IntegerLiteral argument = expression.argumentList.arguments.single;
+    expect(argument.value, 42);
+  }
+
+  void test_bangBeforeFuctionCall2() {
+    // https://github.com/dart-lang/sdk/issues/39776
+    var unit = parseCompilationUnit('f() { Function f2; f2!<int>(42); }');
+    var funct = unit.declarations[0] as FunctionDeclaration;
+    var body = funct.functionExpression.body as BlockFunctionBody;
+    var statement1 = body.block.statements[0] as VariableDeclarationStatement;
+    expect(statement1.toSource(), "Function f2;");
+    var statement2 = body.block.statements[1] as ExpressionStatement;
+
+    // expression is "f2!<int>(42)"
+    var expression = statement2.expression as FunctionExpressionInvocation;
+    expect(expression.toSource(), "f2!<int>(42)");
+
+    var functionExpression = expression.function as PostfixExpression;
+    SimpleIdentifier identifier = functionExpression.operand;
+    expect(identifier.name, 'f2');
+    expect(functionExpression.operator.lexeme, '!');
+
+    expect(expression.typeArguments.arguments.length, 1);
+    TypeName typeArgument = expression.typeArguments.arguments.single;
+    expect(typeArgument.name.name, "int");
+
+    expect(expression.argumentList.arguments.length, 1);
+    IntegerLiteral argument = expression.argumentList.arguments.single;
+    expect(argument.value, 42);
+  }
+
+  void test_bangQuestionIndex() {
+    // http://dartbug.com/41177
+    CompilationUnit unit = parseCompilationUnit('f(dynamic a) { a!?[0]; }');
+    FunctionDeclaration funct = unit.declarations[0];
+    BlockFunctionBody body = funct.functionExpression.body;
+
+    ExpressionStatement statement = body.block.statements[0];
+    IndexExpression expression = statement.expression;
+
+    IntegerLiteral index = expression.index;
+    expect(index.value, 0);
+
+    Token question = expression.question;
+    expect(question, isNotNull);
+    expect(question.lexeme, "?");
+
+    PostfixExpression target = expression.target;
+    SimpleIdentifier identifier = target.operand;
+    expect(identifier.name, 'a');
+    expect(target.operator.lexeme, '!');
+  }
+
+  void test_binary_expression_statement() {
+    final unit = parseCompilationUnit('D? foo(X? x) { X ?? x2; }');
+    FunctionDeclaration funct = unit.declarations[0];
+    BlockFunctionBody body = funct.functionExpression.body;
+    ExpressionStatement statement = body.block.statements[0];
+    BinaryExpression expression = statement.expression;
+    SimpleIdentifier lhs = expression.leftOperand;
+    expect(lhs.name, 'X');
+    expect(expression.operator.lexeme, '??');
+    SimpleIdentifier rhs = expression.rightOperand;
+    expect(rhs.name, 'x2');
+  }
+
+  void test_cascade_withNullCheck_indexExpression() {
+    var unit = parseCompilationUnit('main() { a?..[27]; }');
+    FunctionDeclaration funct = unit.declarations[0];
+    BlockFunctionBody body = funct.functionExpression.body;
+    ExpressionStatement statement = body.block.statements[0];
+    CascadeExpression cascade = statement.expression;
+    IndexExpression indexExpression = cascade.cascadeSections[0];
+    expect(indexExpression.period.lexeme, '?..');
+    expect(indexExpression.toSource(), '?..[27]');
+  }
+
+  void test_cascade_withNullCheck_invalid() {
+    parseCompilationUnit('main() { a..[27]?..x; }', errors: [
+      expectedError(ParserErrorCode.NULL_AWARE_CASCADE_OUT_OF_ORDER, 16, 3),
+    ]);
+  }
+
+  void test_cascade_withNullCheck_methodInvocation() {
+    var unit = parseCompilationUnit('main() { a?..foo(); }');
+    FunctionDeclaration funct = unit.declarations[0];
+    BlockFunctionBody body = funct.functionExpression.body;
+    ExpressionStatement statement = body.block.statements[0];
+    CascadeExpression cascade = statement.expression;
+    MethodInvocation invocation = cascade.cascadeSections[0];
+    expect(invocation.operator.lexeme, '?..');
+    expect(invocation.toSource(), '?..foo()');
+  }
+
+  void test_cascade_withNullCheck_propertyAccess() {
+    var unit = parseCompilationUnit('main() { a?..x27; }');
+    FunctionDeclaration funct = unit.declarations[0];
+    BlockFunctionBody body = funct.functionExpression.body;
+    ExpressionStatement statement = body.block.statements[0];
+    CascadeExpression cascade = statement.expression;
+    PropertyAccess propertyAccess = cascade.cascadeSections[0];
+    expect(propertyAccess.operator.lexeme, '?..');
+    expect(propertyAccess.toSource(), '?..x27');
+  }
+
+  void test_conditional() {
+    parseCompilationUnit('D? foo(X? x) { X ? 7 : y; }');
+  }
+
+  void test_conditional_complex() {
+    parseCompilationUnit('D? foo(X? x) { X ? x2 = x + bar(7) : y; }');
+  }
+
+  void test_conditional_error() {
+    parseCompilationUnit('D? foo(X? x) { X ? ? x2 = x + bar(7) : y; }',
+        errors: [
+          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 19, 1),
+          expectedError(ParserErrorCode.EXPECTED_TOKEN, 40, 1),
+          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 40, 1),
+        ]);
+  }
+
+  void test_conditional_simple() {
+    parseCompilationUnit('D? foo(X? x) { X ? x2 = x : y; }');
+  }
+
+  void test_enableNonNullable_false() {
+    parseCompilationUnit('main() { x is String? ? (x + y) : z; }',
+        errors: [expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 20, 1)],
+        featureSet: preNonNullable);
+  }
+
+  void test_for() {
+    parseCompilationUnit('main() { for(int x = 0; x < 7; ++x) { } }');
+  }
+
+  void test_for_conditional() {
+    parseCompilationUnit('main() { for(x ? y = 7 : y = 8; y < 10; ++y) { } }');
+  }
+
+  void test_for_nullable() {
+    parseCompilationUnit('main() { for(int? x = 0; x < 7; ++x) { } }');
+  }
+
+  void test_foreach() {
+    parseCompilationUnit('main() { for(int x in [7]) { } }');
+  }
+
+  void test_foreach_nullable() {
+    parseCompilationUnit('main() { for(int? x in [7, null]) { } }');
+  }
+
+  void test_functionTypedFormalParameter_nullable_disabled() {
+    parseCompilationUnit('void f(void p()?) {}',
+        errors: [expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 15, 1)],
+        featureSet: preNonNullable);
+  }
+
+  test_fuzz_38113() async {
+    // https://github.com/dart-lang/sdk/issues/38113
+    parseCompilationUnit(r'+t{{r?this}}', errors: [
+      expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 0, 1),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 1, 1),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 4),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 10, 1),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 10, 1),
+    ]);
+  }
+
+  void test_gft_nullable() {
+    parseCompilationUnit('main() { C? Function() x = 7; }');
+  }
+
+  void test_gft_nullable_1() {
+    parseCompilationUnit('main() { C Function()? x = 7; }');
+  }
+
+  void test_gft_nullable_2() {
+    parseCompilationUnit('main() { C? Function()? x = 7; }');
+  }
+
+  void test_gft_nullable_3() {
+    parseCompilationUnit('main() { C? Function()? Function()? x = 7; }');
+  }
+
+  void test_gft_nullable_prefixed() {
+    parseCompilationUnit('main() { C.a? Function()? x = 7; }');
+  }
+
+  void test_indexed() {
+    CompilationUnit unit = parseCompilationUnit('main() { a[7]; }');
+    FunctionDeclaration method = unit.declarations[0];
+    BlockFunctionBody body = method.functionExpression.body;
+    ExpressionStatement statement = body.block.statements[0];
+    IndexExpression expression = statement.expression;
+    expect(expression.leftBracket.lexeme, '[');
+  }
+
+  void test_indexed_nullAware() {
+    CompilationUnit unit = parseCompilationUnit('main() { a?[7]; }');
+    FunctionDeclaration method = unit.declarations[0];
+    BlockFunctionBody body = method.functionExpression.body;
+    ExpressionStatement statement = body.block.statements[0];
+    IndexExpression expression = statement.expression;
+    expect(expression.question, isNotNull);
+    expect(expression.leftBracket.lexeme, '[');
+    expect(expression.rightBracket.lexeme, ']');
+    expect(expression.leftBracket.endGroup, expression.rightBracket);
+  }
+
+  void test_indexed_nullAware_optOut() {
+    CompilationUnit unit = parseCompilationUnit('''
+// @dart = 2.2
+main() { a?[7]; }''',
+        errors: [expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 25, 1)]);
+    FunctionDeclaration method = unit.declarations[0];
+    BlockFunctionBody body = method.functionExpression.body;
+    ExpressionStatement statement = body.block.statements[0];
+    IndexExpressionImpl expression = statement.expression;
+    expect(expression.target.toSource(), 'a');
+    expect(expression.question, isNotNull);
+    expect(expression.leftBracket.lexeme, '[');
+    expect(expression.rightBracket.lexeme, ']');
+    expect(expression.leftBracket.endGroup, expression.rightBracket);
+  }
+
+  void test_indexExpression_nullable_disabled() {
+    parseCompilationUnit('main(a) { a?[0]; }',
+        errors: [expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 11, 1)],
+        featureSet: preNonNullable);
+  }
+
+  void test_is_nullable() {
+    CompilationUnit unit =
+        parseCompilationUnit('main() { x is String? ? (x + y) : z; }');
+    FunctionDeclaration function = unit.declarations[0];
+    BlockFunctionBody body = function.functionExpression.body;
+    ExpressionStatement statement = body.block.statements[0];
+    ConditionalExpression expression = statement.expression;
+
+    IsExpression condition = expression.condition;
+    expect((condition.type as NamedType).question, isNotNull);
+    Expression thenExpression = expression.thenExpression;
+    expect(thenExpression, isParenthesizedExpression);
+    Expression elseExpression = expression.elseExpression;
+    expect(elseExpression, isSimpleIdentifier);
+  }
+
+  void test_is_nullable_parenthesis() {
+    CompilationUnit unit =
+        parseCompilationUnit('main() { (x is String?) ? (x + y) : z; }');
+    FunctionDeclaration function = unit.declarations[0];
+    BlockFunctionBody body = function.functionExpression.body;
+    ExpressionStatement statement = body.block.statements[0];
+    ConditionalExpression expression = statement.expression;
+
+    ParenthesizedExpression condition = expression.condition;
+    IsExpression isExpression = condition.expression;
+    expect((isExpression.type as NamedType).question, isNotNull);
+    Expression thenExpression = expression.thenExpression;
+    expect(thenExpression, isParenthesizedExpression);
+    Expression elseExpression = expression.elseExpression;
+    expect(elseExpression, isSimpleIdentifier);
+  }
+
+  void test_is_nullable_parenthesis_optOut() {
+    parseCompilationUnit('''
+// @dart = 2.2
+main() { (x is String?) ? (x + y) : z; }
+''', errors: [expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 36, 1)]);
+  }
+
+  void test_late_as_identifier() {
+    parseCompilationUnit('''
+class C {
+  int late;
+}
+
+void f(C c) {
+  print(c.late);
+}
+
+main() {
+  f(new C());
+}
+''', featureSet: preNonNullable);
+  }
+
+  void test_late_as_identifier_optOut() {
+    parseCompilationUnit('''
+// @dart = 2.2
+class C {
+  int late;
+}
+
+void f(C c) {
+  print(c.late);
+}
+
+main() {
+  f(new C());
+}
+''');
+  }
+
+  void test_nullableTypeInInitializerList_01() {
+    // http://dartbug.com/40834
+    var unit = parseCompilationUnit(r'''
+class Foo {
+  String? x;
+  int y;
+
+  Foo(Object? o) : x = o as String?, y = 0;
+}
+''');
+    ClassDeclaration classDeclaration = unit.declarations.first;
+    ConstructorDeclaration constructor = classDeclaration.getConstructor(null);
+
+    // Object? o
+    SimpleFormalParameter parameter = constructor.parameters.parameters.single;
+    expect(parameter.identifier.name, 'o');
+    TypeName type = parameter.type;
+    expect(type.question.lexeme, '?');
+    expect(type.name.name, 'Object');
+
+    expect(constructor.initializers.length, 2);
+
+    // o as String?
+    {
+      ConstructorFieldInitializer initializer = constructor.initializers[0];
+      expect(initializer.fieldName.name, 'x');
+      AsExpression expression = initializer.expression;
+      SimpleIdentifier identifier = expression.expression;
+      expect(identifier.name, 'o');
+      TypeName expressionType = expression.type;
+      expect(expressionType.question.lexeme, '?');
+      expect(expressionType.name.name, 'String');
+    }
+
+    // y = 0
+    {
+      ConstructorFieldInitializer initializer = constructor.initializers[1];
+      expect(initializer.fieldName.name, 'y');
+      IntegerLiteral expression = initializer.expression;
+      expect(expression.value, 0);
+    }
+  }
+
+  void test_nullableTypeInInitializerList_02() {
+    var unit = parseCompilationUnit(r'''
+class Foo {
+  String? x;
+  int y;
+
+  Foo(Object? o) : y = o is String? ? o.length : null, x = null;
+}
+''');
+    ClassDeclaration classDeclaration = unit.declarations.first;
+    ConstructorDeclaration constructor = classDeclaration.getConstructor(null);
+
+    // Object? o
+    SimpleFormalParameter parameter = constructor.parameters.parameters.single;
+    expect(parameter.identifier.name, 'o');
+    TypeName type = parameter.type;
+    expect(type.question.lexeme, '?');
+    expect(type.name.name, 'Object');
+
+    expect(constructor.initializers.length, 2);
+
+    // y = o is String? ? o.length : null
+    {
+      ConstructorFieldInitializer initializer = constructor.initializers[0];
+      expect(initializer.fieldName.name, 'y');
+      ConditionalExpression expression = initializer.expression;
+      IsExpression condition = expression.condition;
+      SimpleIdentifier identifier = condition.expression;
+      expect(identifier.name, 'o');
+      TypeName expressionType = condition.type;
+      expect(expressionType.question.lexeme, '?');
+      expect(expressionType.name.name, 'String');
+      PrefixedIdentifier thenExpression = expression.thenExpression;
+      expect(thenExpression.identifier.name, 'length');
+      expect(thenExpression.prefix.name, 'o');
+      NullLiteral elseExpression = expression.elseExpression;
+      expect(elseExpression, isNotNull);
+    }
+
+    // x = null
+    {
+      ConstructorFieldInitializer initializer = constructor.initializers[1];
+      expect(initializer.fieldName.name, 'x');
+      NullLiteral expression = initializer.expression;
+      expect(expression, isNotNull);
+    }
+  }
+
+  void test_nullableTypeInInitializerList_03() {
+    // As test_nullableTypeInInitializerList_02 but without ? on String in is.
+    var unit = parseCompilationUnit(r'''
+class Foo {
+  String? x;
+  int y;
+
+  Foo(Object? o) : y = o is String ? o.length : null, x = null;
+}
+''');
+    ClassDeclaration classDeclaration = unit.declarations.first;
+    ConstructorDeclaration constructor = classDeclaration.getConstructor(null);
+
+    // Object? o
+    SimpleFormalParameter parameter = constructor.parameters.parameters.single;
+    expect(parameter.identifier.name, 'o');
+    TypeName type = parameter.type;
+    expect(type.question.lexeme, '?');
+    expect(type.name.name, 'Object');
+
+    expect(constructor.initializers.length, 2);
+
+    // y = o is String ? o.length : null
+    {
+      ConstructorFieldInitializer initializer = constructor.initializers[0];
+      expect(initializer.fieldName.name, 'y');
+      ConditionalExpression expression = initializer.expression;
+      IsExpression condition = expression.condition;
+      SimpleIdentifier identifier = condition.expression;
+      expect(identifier.name, 'o');
+      TypeName expressionType = condition.type;
+      expect(expressionType.question, isNull);
+      expect(expressionType.name.name, 'String');
+      PrefixedIdentifier thenExpression = expression.thenExpression;
+      expect(thenExpression.identifier.name, 'length');
+      expect(thenExpression.prefix.name, 'o');
+      NullLiteral elseExpression = expression.elseExpression;
+      expect(elseExpression, isNotNull);
+    }
+
+    // x = null
+    {
+      ConstructorFieldInitializer initializer = constructor.initializers[1];
+      expect(initializer.fieldName.name, 'x');
+      NullLiteral expression = initializer.expression;
+      expect(expression, isNotNull);
+    }
+  }
+
+  void test_nullCheck() {
+    var unit = parseCompilationUnit('f(int? y) { var x = y!; }');
+    FunctionDeclaration function = unit.declarations[0];
+    BlockFunctionBody body = function.functionExpression.body;
+    VariableDeclarationStatement statement = body.block.statements[0];
+    PostfixExpression expression = statement.variables.variables[0].initializer;
+    SimpleIdentifier identifier = expression.operand;
+    expect(identifier.name, 'y');
+    expect(expression.operator.lexeme, '!');
+  }
+
+  void test_nullCheck_disabled() {
+    var unit = parseCompilationUnit('f(int? y) { var x = y!; }',
+        errors: [
+          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 5, 1),
+          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 21, 1),
+        ],
+        featureSet: preNonNullable);
+    FunctionDeclaration function = unit.declarations[0];
+    BlockFunctionBody body = function.functionExpression.body;
+    VariableDeclarationStatement statement = body.block.statements[0];
+    SimpleIdentifier identifier = statement.variables.variables[0].initializer;
+    expect(identifier.name, 'y');
+  }
+
+  void test_nullCheckAfterGetterAccess() {
+    parseCompilationUnit('f() { var x = g.x!.y + 7; }');
+  }
+
+  void test_nullCheckAfterMethodCall() {
+    parseCompilationUnit('f() { var x = g.m()!.y + 7; }');
+  }
+
+  void test_nullCheckBeforeGetterAccess() {
+    parseCompilationUnit('f() { var x = g!.x + 7; }');
+  }
+
+  void test_nullCheckBeforeIndex() {
+    // https://github.com/dart-lang/sdk/issues/37708
+    var unit = parseCompilationUnit('f() { foo.bar!.baz[arg]; }');
+    var funct = unit.declarations[0] as FunctionDeclaration;
+    var body = funct.functionExpression.body as BlockFunctionBody;
+    var statement = body.block.statements[0] as ExpressionStatement;
+    var expression = statement.expression as IndexExpression;
+    expect(expression.index.toSource(), 'arg');
+    var propertyAccess = expression.target as PropertyAccess;
+    expect(propertyAccess.propertyName.toSource(), 'baz');
+    var target = propertyAccess.target as PostfixExpression;
+    expect(target.operand.toSource(), 'foo.bar');
+    expect(target.operator.lexeme, '!');
+  }
+
+  void test_nullCheckBeforeMethodCall() {
+    parseCompilationUnit('f() { var x = g!.m() + 7; }');
+  }
+
+  void test_nullCheckFunctionResult() {
+    parseCompilationUnit('f() { var x = g()! + 7; }');
+  }
+
+  void test_nullCheckIndexedValue() {
+    parseCompilationUnit('f(int? y) { var x = y[0]! + 7; }');
+  }
+
+  void test_nullCheckIndexedValue2() {
+    parseCompilationUnit('f(int? y) { var x = super.y[0]! + 7; }');
+  }
+
+  void test_nullCheckInExpression() {
+    parseCompilationUnit('f(int? y) { var x = y! + 7; }');
+  }
+
+  void test_nullCheckInExpression_disabled() {
+    parseCompilationUnit('f(int? y) { var x = y! + 7; }',
+        errors: [
+          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 5, 1),
+          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 21, 1),
+        ],
+        featureSet: preNonNullable);
+  }
+
+  void test_nullCheckMethodResult() {
+    parseCompilationUnit('f() { var x = g.m()! + 7; }');
+  }
+
+  void test_nullCheckMethodResult2() {
+    parseCompilationUnit('f() { var x = g?.m()! + 7; }');
+  }
+
+  void test_nullCheckMethodResult3() {
+    parseCompilationUnit('f() { var x = super.m()! + 7; }');
+  }
+
+  void test_nullCheckOnConstConstructor() {
+    parseCompilationUnit('f() { var x = const Foo()!; }');
+  }
+
+  void test_nullCheckOnConstructor() {
+    parseCompilationUnit('f() { var x = new Foo()!; }');
+  }
+
+  void test_nullCheckOnIndex() {
+    // https://github.com/dart-lang/sdk/issues/37708
+    var unit = parseCompilationUnit('f() { obj![arg]; }');
+    var funct = unit.declarations[0] as FunctionDeclaration;
+    var body = funct.functionExpression.body as BlockFunctionBody;
+    var statement = body.block.statements[0] as ExpressionStatement;
+    var expression = statement.expression as IndexExpression;
+    var target = expression.target as PostfixExpression;
+    expect(target.operand.toSource(), 'obj');
+    expect(target.operator.lexeme, '!');
+  }
+
+  void test_nullCheckOnIndex2() {
+    // https://github.com/dart-lang/sdk/issues/37708
+    var unit = parseCompilationUnit('f() { obj![arg]![arg2]; }');
+    var funct = unit.declarations[0] as FunctionDeclaration;
+    var body = funct.functionExpression.body as BlockFunctionBody;
+    var statement = body.block.statements[0] as ExpressionStatement;
+    var expression = statement.expression as IndexExpression;
+    expect(expression.index.toSource(), 'arg2');
+    var target = expression.target as PostfixExpression;
+    expect(target.operator.lexeme, '!');
+    expression = target.operand as IndexExpression;
+    expect(expression.index.toSource(), 'arg');
+    target = expression.target as PostfixExpression;
+    expect(target.operator.lexeme, '!');
+    expect(target.operand.toSource(), 'obj');
+  }
+
+  void test_nullCheckOnIndex3() {
+    // https://github.com/dart-lang/sdk/issues/37708
+    var unit = parseCompilationUnit('f() { foo.bar![arg]; }');
+    var funct = unit.declarations[0] as FunctionDeclaration;
+    var body = funct.functionExpression.body as BlockFunctionBody;
+    var statement = body.block.statements[0] as ExpressionStatement;
+    var expression = statement.expression as IndexExpression;
+    expect(expression.index.toSource(), 'arg');
+    var target = expression.target as PostfixExpression;
+    expect(target.operand.toSource(), 'foo.bar');
+    expect(target.operator.lexeme, '!');
+  }
+
+  void test_nullCheckOnIndex4() {
+    // https://github.com/dart-lang/sdk/issues/37708
+    var unit = parseCompilationUnit('f() { foo!.bar![arg]; }');
+    var funct = unit.declarations[0] as FunctionDeclaration;
+    var body = funct.functionExpression.body as BlockFunctionBody;
+    var statement = body.block.statements[0] as ExpressionStatement;
+    var expression = statement.expression as IndexExpression;
+    var fooBarTarget = expression.target as PostfixExpression;
+    expect(fooBarTarget.toSource(), "foo!.bar!");
+    var propertyAccess = fooBarTarget.operand as PropertyAccess;
+    var targetFoo = propertyAccess.target as PostfixExpression;
+    expect(targetFoo.operand.toSource(), "foo");
+    expect(targetFoo.operator.lexeme, "!");
+    expect(propertyAccess.propertyName.toSource(), "bar");
+    expect(fooBarTarget.operator.lexeme, '!');
+    expect(expression.index.toSource(), 'arg');
+  }
+
+  void test_nullCheckOnIndex5() {
+    // https://github.com/dart-lang/sdk/issues/37708
+    var unit = parseCompilationUnit('f() { foo.bar![arg]![arg2]; }');
+    var funct = unit.declarations[0] as FunctionDeclaration;
+    var body = funct.functionExpression.body as BlockFunctionBody;
+    var statement = body.block.statements[0] as ExpressionStatement;
+    var expression = statement.expression as IndexExpression;
+    expect(expression.index.toSource(), 'arg2');
+    var target = expression.target as PostfixExpression;
+    expect(target.operator.lexeme, '!');
+    expression = target.operand as IndexExpression;
+    expect(expression.index.toSource(), 'arg');
+    target = expression.target as PostfixExpression;
+    expect(target.operator.lexeme, '!');
+    expect(target.operand.toSource(), 'foo.bar');
+  }
+
+  void test_nullCheckOnIndex6() {
+    // https://github.com/dart-lang/sdk/issues/37708
+    var unit = parseCompilationUnit('f() { foo!.bar![arg]![arg2]; }');
+    var funct = unit.declarations[0] as FunctionDeclaration;
+    var body = funct.functionExpression.body as BlockFunctionBody;
+    var statement = body.block.statements[0] as ExpressionStatement;
+
+    // expression is "foo!.bar![arg]![arg2]"
+    var expression = statement.expression as IndexExpression;
+    expect(expression.index.toSource(), 'arg2');
+
+    // target is "foo!.bar![arg]!"
+    var target = expression.target as PostfixExpression;
+    expect(target.operator.lexeme, '!');
+
+    // expression is "foo!.bar![arg]"
+    expression = target.operand as IndexExpression;
+    expect(expression.index.toSource(), 'arg');
+
+    // target is "foo!.bar!"
+    target = expression.target as PostfixExpression;
+    expect(target.operator.lexeme, '!');
+
+    // propertyAccess is "foo!.bar"
+    PropertyAccess propertyAccess = target.operand as PropertyAccess;
+    expect(propertyAccess.propertyName.toSource(), "bar");
+
+    // target is "foo!"
+    target = propertyAccess.target as PostfixExpression;
+    expect(target.operator.lexeme, '!');
+
+    expect(target.operand.toSource(), "foo");
+  }
+
+  void test_nullCheckOnLiteral_disabled() {
+    parseCompilationUnit('f() { var x = 0!; }',
+        errors: [expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 15, 1)],
+        featureSet: preNonNullable);
+  }
+
+  void test_nullCheckOnLiteralDouble() {
+    // Issues like this should be caught during later analysis
+    parseCompilationUnit('f() { var x = 1.2!; }');
+  }
+
+  void test_nullCheckOnLiteralInt() {
+    // Issues like this should be caught during later analysis
+    parseCompilationUnit('f() { var x = 0!; }');
+  }
+
+  void test_nullCheckOnLiteralList() {
+    // Issues like this should be caught during later analysis
+    parseCompilationUnit('f() { var x = [1,2]!; }');
+  }
+
+  void test_nullCheckOnLiteralMap() {
+    // Issues like this should be caught during later analysis
+    parseCompilationUnit('f() { var x = {1:2}!; }');
+  }
+
+  void test_nullCheckOnLiteralSet() {
+    // Issues like this should be caught during later analysis
+    parseCompilationUnit('f() { var x = {1,2}!; }');
+  }
+
+  void test_nullCheckOnLiteralString() {
+    // Issues like this should be caught during later analysis
+    parseCompilationUnit('f() { var x = "seven"!; }');
+  }
+
+  void test_nullCheckOnNull() {
+    // Issues like this should be caught during later analysis
+    parseCompilationUnit('f() { var x = null!; }');
+  }
+
+  void test_nullCheckOnSend() {
+    // https://github.com/dart-lang/sdk/issues/37708
+    var unit = parseCompilationUnit('f() { obj!(arg); }');
+    var funct = unit.declarations[0] as FunctionDeclaration;
+    var body = funct.functionExpression.body as BlockFunctionBody;
+    var statement = body.block.statements[0] as ExpressionStatement;
+    var expression = statement.expression as FunctionExpressionInvocation;
+    var target = expression.function as PostfixExpression;
+    expect(target.operand.toSource(), 'obj');
+    expect(target.operator.lexeme, '!');
+  }
+
+  void test_nullCheckOnSend2() {
+    // https://github.com/dart-lang/sdk/issues/37708
+    var unit = parseCompilationUnit('f() { obj!(arg)!(arg2); }');
+    var funct = unit.declarations[0] as FunctionDeclaration;
+    var body = funct.functionExpression.body as BlockFunctionBody;
+    var statement = body.block.statements[0] as ExpressionStatement;
+    var expression = statement.expression as FunctionExpressionInvocation;
+    expect(expression.argumentList.toSource(), '(arg2)');
+    var target = expression.function as PostfixExpression;
+    expect(target.operator.lexeme, '!');
+    expression = target.operand as FunctionExpressionInvocation;
+    expect(expression.argumentList.toSource(), '(arg)');
+    target = expression.function as PostfixExpression;
+    expect(target.operator.lexeme, '!');
+    expect(target.operand.toSource(), 'obj');
+  }
+
+  void test_nullCheckOnSymbol() {
+    // Issues like this should be caught during later analysis
+    parseCompilationUnit('f() { var x = #seven!; }');
+  }
+
+  void test_nullCheckOnValue() {
+    parseCompilationUnit('f(Point p) { var x = p.y! + 7; }');
+  }
+
+  void test_nullCheckOnValue_disabled() {
+    parseCompilationUnit('f(Point p) { var x = p.y! + 7; }',
+        errors: [expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 24, 1)],
+        featureSet: preNonNullable);
+  }
+
+  void test_nullCheckParenthesizedExpression() {
+    parseCompilationUnit('f(int? y) { var x = (y)! + 7; }');
+  }
+
+  void test_nullCheckPropertyAccess() {
+    parseCompilationUnit('f() { var x = g.p! + 7; }');
+  }
+
+  void test_nullCheckPropertyAccess2() {
+    parseCompilationUnit('f() { var x = g?.p! + 7; }');
+  }
+
+  void test_nullCheckPropertyAccess3() {
+    parseCompilationUnit('f() { var x = super.p! + 7; }');
+  }
+
+  void test_postfix_null_assertion_and_unary_prefix_operator_precedence() {
+    // -x! is parsed as -(x!).
+    var unit = parseCompilationUnit('void main() { -x!; }');
+    var function = unit.declarations[0] as FunctionDeclaration;
+    var body = function.functionExpression.body as BlockFunctionBody;
+    var statement = body.block.statements[0] as ExpressionStatement;
+    var outerExpression = statement.expression as PrefixExpression;
+    expect(outerExpression.operator.type, TokenType.MINUS);
+    var innerExpression = outerExpression.operand as PostfixExpression;
+    expect(innerExpression.operator.type, TokenType.BANG);
+  }
+
+  void test_postfix_null_assertion_of_postfix_expression() {
+    // x++! is parsed as (x++)!.
+    var unit = parseCompilationUnit('void main() { x++!; }');
+    var function = unit.declarations[0] as FunctionDeclaration;
+    var body = function.functionExpression.body as BlockFunctionBody;
+    var statement = body.block.statements[0] as ExpressionStatement;
+    var outerExpression = statement.expression as PostfixExpression;
+    expect(outerExpression.operator.type, TokenType.BANG);
+    var innerExpression = outerExpression.operand as PostfixExpression;
+    expect(innerExpression.operator.type, TokenType.PLUS_PLUS);
+  }
+
+  void test_typeName_nullable_disabled() {
+    parseCompilationUnit('int? x;',
+        errors: [expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 3, 1)],
+        featureSet: preNonNullable);
+  }
+}
diff --git a/pkg/analyzer/test/generated/non_error_parser_test.dart b/pkg/analyzer/test/generated/non_error_parser_test.dart
new file mode 100644
index 0000000..e802f3d
--- /dev/null
+++ b/pkg/analyzer/test/generated/non_error_parser_test.dart
@@ -0,0 +1,43 @@
+// Copyright (c) 2020, 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.
+
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'parser_test_base.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(NonErrorParserTest);
+  });
+}
+
+@reflectiveTest
+class NonErrorParserTest extends ParserTestCase {
+  void test_annotationOnEnumConstant_first() {
+    createParser("enum E { @override C }");
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    assertNoErrors();
+  }
+
+  void test_annotationOnEnumConstant_middle() {
+    createParser("enum E { C, @override D, E }");
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    assertNoErrors();
+  }
+
+  void test_staticMethod_notParsingFunctionBodies() {
+    ParserTestCase.parseFunctionBodies = false;
+    try {
+      createParser('class C { static void m() {} }');
+      CompilationUnit unit = parser.parseCompilationUnit2();
+      expectNotNullIfNoErrors(unit);
+      assertNoErrors();
+    } finally {
+      ParserTestCase.parseFunctionBodies = true;
+    }
+  }
+}
diff --git a/pkg/analyzer/test/generated/parser_fasta_test.dart b/pkg/analyzer/test/generated/parser_fasta_test.dart
deleted file mode 100644
index 2fa5b17..0000000
--- a/pkg/analyzer/test/generated/parser_fasta_test.dart
+++ /dev/null
@@ -1,2618 +0,0 @@
-// Copyright (c) 2017, 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.
-
-import 'package:analyzer/dart/analysis/features.dart';
-import 'package:analyzer/dart/ast/ast.dart';
-import 'package:analyzer/dart/ast/token.dart' as analyzer;
-import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
-import 'package:analyzer/error/error.dart';
-import 'package:analyzer/src/dart/ast/ast.dart';
-import 'package:analyzer/src/dart/scanner/scanner.dart';
-import 'package:analyzer/src/error/codes.dart';
-import 'package:test/test.dart';
-import 'package:test_reflective_loader/test_reflective_loader.dart';
-
-import '../util/ast_type_matchers.dart';
-import 'parser_test.dart';
-import 'parser_test_base.dart';
-import 'test_support.dart';
-
-main() {
-  defineReflectiveSuite(() {
-    // TODO(srawlins): Move each of these test classes into [parser_test.dart];
-    // merge with mixins, as each mixin is only used once now; remove this file.
-    defineReflectiveTests(CollectionLiteralParserTest);
-    defineReflectiveTests(NNBDParserTest_Fasta);
-    defineReflectiveTests(RecoveryParserTest_Fasta);
-    defineReflectiveTests(SimpleParserTest_Fasta);
-    defineReflectiveTests(StatementParserTest_Fasta);
-    defineReflectiveTests(TopLevelParserTest_Fasta);
-    defineReflectiveTests(VarianceParserTest_Fasta);
-  });
-}
-
-/// Type of the "parse..." methods defined in the Fasta parser.
-typedef ParseFunction = analyzer.Token Function(analyzer.Token token);
-
-/// Tests of the fasta parser based on [ExpressionParserTestMixin].
-@reflectiveTest
-class CollectionLiteralParserTest extends FastaParserTestCase {
-  Expression parseCollectionLiteral(String source,
-      {List<ErrorCode> codes,
-      List<ExpectedError> errors,
-      int expectedEndOffset,
-      bool inAsync = false}) {
-    return parseExpression(source,
-        codes: codes,
-        errors: errors,
-        expectedEndOffset: expectedEndOffset,
-        inAsync: inAsync,
-        featureSet: FeatureSet.forTesting(
-            sdkVersion: '2.0.0',
-            additionalFeatures: [
-              Feature.spread_collections,
-              Feature.control_flow_collections
-            ]));
-  }
-
-  void test_listLiteral_for() {
-    var list = parseCollectionLiteral(
-      '[1, await for (var x in list) 2]',
-      inAsync: true,
-    ) as ListLiteral;
-    expect(list.elements, hasLength(2));
-    var first = list.elements[0] as IntegerLiteral;
-    expect(first.value, 1);
-
-    var second = list.elements[1] as ForElement;
-    expect(second.awaitKeyword, isNotNull);
-    expect(second.forKeyword.isKeyword, isTrue);
-    expect(second.leftParenthesis.lexeme, '(');
-    expect(second.rightParenthesis.lexeme, ')');
-    var forLoopParts = second.forLoopParts as ForEachPartsWithDeclaration;
-    DeclaredIdentifier forLoopVar = forLoopParts.loopVariable;
-    expect(forLoopVar.identifier.name, 'x');
-    expect(forLoopParts.inKeyword, isNotNull);
-    var iterable = forLoopParts.iterable as SimpleIdentifier;
-    expect(iterable.name, 'list');
-  }
-
-  void test_listLiteral_forIf() {
-    var list = parseCollectionLiteral(
-      '[1, await for (var x in list) if (c) 2]',
-      inAsync: true,
-    ) as ListLiteral;
-    expect(list.elements, hasLength(2));
-    var first = list.elements[0] as IntegerLiteral;
-    expect(first.value, 1);
-
-    var second = list.elements[1] as ForElement;
-    expect(second.awaitKeyword, isNotNull);
-    expect(second.forKeyword.isKeyword, isTrue);
-    expect(second.leftParenthesis.lexeme, '(');
-    expect(second.rightParenthesis.lexeme, ')');
-    var forLoopParts = second.forLoopParts as ForEachPartsWithDeclaration;
-    DeclaredIdentifier forLoopVar = forLoopParts.loopVariable;
-    expect(forLoopVar.identifier.name, 'x');
-    expect(forLoopParts.inKeyword, isNotNull);
-    var iterable = forLoopParts.iterable as SimpleIdentifier;
-    expect(iterable.name, 'list');
-
-    var body = second.body as IfElement;
-    var condition = body.condition as SimpleIdentifier;
-    expect(condition.name, 'c');
-    var thenElement = body.thenElement as IntegerLiteral;
-    expect(thenElement.value, 2);
-  }
-
-  void test_listLiteral_forSpread() {
-    var list =
-        parseCollectionLiteral('[1, for (int x = 0; x < 10; ++x) ...[2]]')
-            as ListLiteral;
-    expect(list.elements, hasLength(2));
-    var first = list.elements[0] as IntegerLiteral;
-    expect(first.value, 1);
-
-    var second = list.elements[1] as ForElement;
-    expect(second.awaitKeyword, isNull);
-    expect(second.forKeyword.isKeyword, isTrue);
-    expect(second.leftParenthesis.lexeme, '(');
-    expect(second.rightParenthesis.lexeme, ')');
-    var forLoopParts = second.forLoopParts as ForPartsWithDeclarations;
-    VariableDeclaration forLoopVar = forLoopParts.variables.variables[0];
-    expect(forLoopVar.name.name, 'x');
-    var condition = forLoopParts.condition as BinaryExpression;
-    var rightOperand = condition.rightOperand as IntegerLiteral;
-    expect(rightOperand.value, 10);
-    var updater = forLoopParts.updaters[0] as PrefixExpression;
-    var updaterOperand = updater.operand as SimpleIdentifier;
-    expect(updaterOperand.name, 'x');
-  }
-
-  void test_listLiteral_if() {
-    var list = parseCollectionLiteral('[1, if (true) 2]') as ListLiteral;
-    expect(list.elements, hasLength(2));
-    var first = list.elements[0] as IntegerLiteral;
-    expect(first.value, 1);
-
-    var second = list.elements[1] as IfElement;
-    var condition = second.condition as BooleanLiteral;
-    expect(condition.value, isTrue);
-    var thenElement = second.thenElement as IntegerLiteral;
-    expect(thenElement.value, 2);
-    expect(second.elseElement, isNull);
-  }
-
-  void test_listLiteral_ifElse() {
-    var list = parseCollectionLiteral('[1, if (true) 2 else 5]') as ListLiteral;
-    expect(list.elements, hasLength(2));
-    var first = list.elements[0] as IntegerLiteral;
-    expect(first.value, 1);
-
-    var second = list.elements[1] as IfElement;
-    var condition = second.condition as BooleanLiteral;
-    expect(condition.value, isTrue);
-    var thenElement = second.thenElement as IntegerLiteral;
-    expect(thenElement.value, 2);
-    var elseElement = second.elseElement as IntegerLiteral;
-    expect(elseElement.value, 5);
-  }
-
-  void test_listLiteral_ifElseFor() {
-    var list = parseCollectionLiteral('[1, if (true) 2 else for (a in b) 5]')
-        as ListLiteral;
-    expect(list.elements, hasLength(2));
-    var first = list.elements[0] as IntegerLiteral;
-    expect(first.value, 1);
-
-    var second = list.elements[1] as IfElement;
-    var condition = second.condition as BooleanLiteral;
-    expect(condition.value, isTrue);
-    var thenElement = second.thenElement as IntegerLiteral;
-    expect(thenElement.value, 2);
-
-    var elseElement = second.elseElement as ForElement;
-    var forLoopParts = elseElement.forLoopParts as ForEachPartsWithIdentifier;
-    expect(forLoopParts.identifier.name, 'a');
-
-    var forValue = elseElement.body as IntegerLiteral;
-    expect(forValue.value, 5);
-  }
-
-  void test_listLiteral_ifElseSpread() {
-    var list = parseCollectionLiteral('[1, if (true) ...[2] else ...?[5]]')
-        as ListLiteral;
-    expect(list.elements, hasLength(2));
-    var first = list.elements[0] as IntegerLiteral;
-    expect(first.value, 1);
-
-    var second = list.elements[1] as IfElement;
-    var condition = second.condition as BooleanLiteral;
-    expect(condition.value, isTrue);
-    var thenElement = second.thenElement as SpreadElement;
-    expect(thenElement.spreadOperator.lexeme, '...');
-    var elseElement = second.elseElement as SpreadElement;
-    expect(elseElement.spreadOperator.lexeme, '...?');
-  }
-
-  void test_listLiteral_ifFor() {
-    var list =
-        parseCollectionLiteral('[1, if (true) for (a in b) 2]') as ListLiteral;
-    expect(list.elements, hasLength(2));
-    var first = list.elements[0] as IntegerLiteral;
-    expect(first.value, 1);
-
-    var second = list.elements[1] as IfElement;
-    var condition = second.condition as BooleanLiteral;
-    expect(condition.value, isTrue);
-
-    var thenElement = second.thenElement as ForElement;
-    var forLoopParts = thenElement.forLoopParts as ForEachPartsWithIdentifier;
-    expect(forLoopParts.identifier.name, 'a');
-
-    var forValue = thenElement.body as IntegerLiteral;
-    expect(forValue.value, 2);
-    expect(second.elseElement, isNull);
-  }
-
-  void test_listLiteral_ifSpread() {
-    var list = parseCollectionLiteral('[1, if (true) ...[2]]') as ListLiteral;
-    expect(list.elements, hasLength(2));
-    var first = list.elements[0] as IntegerLiteral;
-    expect(first.value, 1);
-
-    var second = list.elements[1] as IfElement;
-    var condition = second.condition as BooleanLiteral;
-    expect(condition.value, isTrue);
-    var thenElement = second.thenElement as SpreadElement;
-    expect(thenElement.spreadOperator.lexeme, '...');
-    expect(second.elseElement, isNull);
-  }
-
-  void test_listLiteral_spread() {
-    var list = parseCollectionLiteral('[1, ...[2]]') as ListLiteral;
-    expect(list.elements, hasLength(2));
-    var first = list.elements[0] as IntegerLiteral;
-    expect(first.value, 1);
-
-    var element = list.elements[1] as SpreadElement;
-    expect(element.spreadOperator.lexeme, '...');
-    var spreadExpression = element.expression as ListLiteral;
-    expect(spreadExpression.elements, hasLength(1));
-  }
-
-  void test_listLiteral_spreadQ() {
-    var list = parseCollectionLiteral('[1, ...?[2]]') as ListLiteral;
-    expect(list.elements, hasLength(2));
-    var first = list.elements[0] as IntegerLiteral;
-    expect(first.value, 1);
-
-    var element = list.elements[1] as SpreadElement;
-    expect(element.spreadOperator.lexeme, '...?');
-    var spreadExpression = element.expression as ListLiteral;
-    expect(spreadExpression.elements, hasLength(1));
-  }
-
-  void test_mapLiteral_for() {
-    var map = parseCollectionLiteral('{1:7, await for (y in list) 2:3}',
-        inAsync: true) as SetOrMapLiteral;
-    expect(map.elements, hasLength(2));
-    var first = map.elements[0] as MapLiteralEntry;
-    var firstValue = first.value as IntegerLiteral;
-    expect(firstValue.value, 7);
-
-    var second = map.elements[1] as ForElement;
-    expect(second.awaitKeyword, isNotNull);
-    expect(second.forKeyword.isKeyword, isTrue);
-    expect(second.leftParenthesis.lexeme, '(');
-    expect(second.rightParenthesis.lexeme, ')');
-    var forLoopParts = second.forLoopParts as ForEachPartsWithIdentifier;
-    SimpleIdentifier forLoopVar = forLoopParts.identifier;
-    expect(forLoopVar.name, 'y');
-    expect(forLoopParts.inKeyword, isNotNull);
-    var iterable = forLoopParts.iterable as SimpleIdentifier;
-    expect(iterable.name, 'list');
-  }
-
-  void test_mapLiteral_forIf() {
-    var map = parseCollectionLiteral('{1:7, await for (y in list) if (c) 2:3}',
-        inAsync: true) as SetOrMapLiteral;
-    expect(map.elements, hasLength(2));
-    var first = map.elements[0] as MapLiteralEntry;
-    var firstValue = first.value as IntegerLiteral;
-    expect(firstValue.value, 7);
-
-    var second = map.elements[1] as ForElement;
-    expect(second.awaitKeyword, isNotNull);
-    expect(second.forKeyword.isKeyword, isTrue);
-    expect(second.leftParenthesis.lexeme, '(');
-    expect(second.rightParenthesis.lexeme, ')');
-    var forLoopParts = second.forLoopParts as ForEachPartsWithIdentifier;
-    SimpleIdentifier forLoopVar = forLoopParts.identifier;
-    expect(forLoopVar.name, 'y');
-    expect(forLoopParts.inKeyword, isNotNull);
-    var iterable = forLoopParts.iterable as SimpleIdentifier;
-    expect(iterable.name, 'list');
-
-    var body = second.body as IfElement;
-    var condition = body.condition as SimpleIdentifier;
-    expect(condition.name, 'c');
-    var thenElement = body.thenElement as MapLiteralEntry;
-    var thenValue = thenElement.value as IntegerLiteral;
-    expect(thenValue.value, 3);
-  }
-
-  void test_mapLiteral_forSpread() {
-    var map = parseCollectionLiteral('{1:7, for (x = 0; x < 10; ++x) ...{2:3}}')
-        as SetOrMapLiteral;
-    expect(map.elements, hasLength(2));
-    var first = map.elements[0] as MapLiteralEntry;
-    var firstValue = first.value as IntegerLiteral;
-    expect(firstValue.value, 7);
-
-    var second = map.elements[1] as ForElement;
-    expect(second.awaitKeyword, isNull);
-    expect(second.forKeyword.isKeyword, isTrue);
-    expect(second.leftParenthesis.lexeme, '(');
-    expect(second.rightParenthesis.lexeme, ')');
-    var forLoopParts = second.forLoopParts as ForPartsWithExpression;
-    var forLoopInit = forLoopParts.initialization as AssignmentExpression;
-    var forLoopVar = forLoopInit.leftHandSide as SimpleIdentifier;
-    expect(forLoopVar.name, 'x');
-    var condition = forLoopParts.condition as BinaryExpression;
-    var rightOperand = condition.rightOperand as IntegerLiteral;
-    expect(rightOperand.value, 10);
-    var updater = forLoopParts.updaters[0] as PrefixExpression;
-    var updaterOperand = updater.operand as SimpleIdentifier;
-    expect(updaterOperand.name, 'x');
-  }
-
-  void test_mapLiteral_if() {
-    var map = parseCollectionLiteral('{1:1, if (true) 2:4}') as SetOrMapLiteral;
-    expect(map.elements, hasLength(2));
-    var first = map.elements[0] as MapLiteralEntry;
-    var firstValue = first.value as IntegerLiteral;
-    expect(firstValue.value, 1);
-
-    var second = map.elements[1] as IfElement;
-    var condition = second.condition as BooleanLiteral;
-    expect(condition.value, isTrue);
-    var thenElement = second.thenElement as MapLiteralEntry;
-    var thenElementValue = thenElement.value as IntegerLiteral;
-    expect(thenElementValue.value, 4);
-    expect(second.elseElement, isNull);
-  }
-
-  void test_mapLiteral_ifElse() {
-    var map = parseCollectionLiteral('{1:1, if (true) 2:4 else 5:6}')
-        as SetOrMapLiteral;
-    expect(map.elements, hasLength(2));
-    var first = map.elements[0] as MapLiteralEntry;
-    var firstValue = first.value as IntegerLiteral;
-    expect(firstValue.value, 1);
-
-    var second = map.elements[1] as IfElement;
-    var condition = second.condition as BooleanLiteral;
-    expect(condition.value, isTrue);
-    var thenElement = second.thenElement as MapLiteralEntry;
-    var thenElementValue = thenElement.value as IntegerLiteral;
-    expect(thenElementValue.value, 4);
-    var elseElement = second.elseElement as MapLiteralEntry;
-    var elseElementValue = elseElement.value as IntegerLiteral;
-    expect(elseElementValue.value, 6);
-  }
-
-  void test_mapLiteral_ifElseFor() {
-    var map =
-        parseCollectionLiteral('{1:1, if (true) 2:4 else for (c in d) 5:6}')
-            as SetOrMapLiteral;
-    expect(map.elements, hasLength(2));
-    var first = map.elements[0] as MapLiteralEntry;
-    var firstValue = first.value as IntegerLiteral;
-    expect(firstValue.value, 1);
-
-    var second = map.elements[1] as IfElement;
-    var condition = second.condition as BooleanLiteral;
-    expect(condition.value, isTrue);
-    var thenElement = second.thenElement as MapLiteralEntry;
-    var thenElementValue = thenElement.value as IntegerLiteral;
-    expect(thenElementValue.value, 4);
-
-    var elseElement = second.elseElement as ForElement;
-    var forLoopParts = elseElement.forLoopParts as ForEachPartsWithIdentifier;
-    expect(forLoopParts.identifier.name, 'c');
-
-    var body = elseElement.body as MapLiteralEntry;
-    var bodyValue = body.value as IntegerLiteral;
-    expect(bodyValue.value, 6);
-  }
-
-  void test_mapLiteral_ifElseSpread() {
-    var map = parseCollectionLiteral('{1:7, if (true) ...{2:4} else ...?{5:6}}')
-        as SetOrMapLiteral;
-    expect(map.elements, hasLength(2));
-    var first = map.elements[0] as MapLiteralEntry;
-    var firstValue = first.value as IntegerLiteral;
-    expect(firstValue.value, 7);
-
-    var second = map.elements[1] as IfElement;
-    var condition = second.condition as BooleanLiteral;
-    expect(condition.value, isTrue);
-    var thenElement = second.thenElement as SpreadElement;
-    expect(thenElement.spreadOperator.lexeme, '...');
-    var elseElement = second.elseElement as SpreadElement;
-    expect(elseElement.spreadOperator.lexeme, '...?');
-    var elseElementExpression = elseElement.expression as SetOrMapLiteral;
-    expect(elseElementExpression.elements, hasLength(1));
-    var entry = elseElementExpression.elements[0] as MapLiteralEntry;
-    var entryValue = entry.value as IntegerLiteral;
-    expect(entryValue.value, 6);
-  }
-
-  void test_mapLiteral_ifFor() {
-    var map = parseCollectionLiteral('{1:1, if (true) for (a in b) 2:4}')
-        as SetOrMapLiteral;
-    expect(map.elements, hasLength(2));
-    var first = map.elements[0] as MapLiteralEntry;
-    var firstValue = first.value as IntegerLiteral;
-    expect(firstValue.value, 1);
-
-    var second = map.elements[1] as IfElement;
-    var condition = second.condition as BooleanLiteral;
-    expect(condition.value, isTrue);
-
-    var thenElement = second.thenElement as ForElement;
-    var forLoopParts = thenElement.forLoopParts as ForEachPartsWithIdentifier;
-    expect(forLoopParts.identifier.name, 'a');
-
-    var body = thenElement.body as MapLiteralEntry;
-    var thenElementValue = body.value as IntegerLiteral;
-    expect(thenElementValue.value, 4);
-    expect(second.elseElement, isNull);
-  }
-
-  void test_mapLiteral_ifSpread() {
-    SetOrMapLiteral map = parseCollectionLiteral('{1:1, if (true) ...{2:4}}');
-    expect(map.elements, hasLength(2));
-    var first = map.elements[0] as MapLiteralEntry;
-    var firstValue = first.value as IntegerLiteral;
-    expect(firstValue.value, 1);
-
-    var second = map.elements[1] as IfElement;
-    var condition = second.condition as BooleanLiteral;
-    expect(condition.value, isTrue);
-    var thenElement = second.thenElement as SpreadElement;
-    expect(thenElement.spreadOperator.lexeme, '...');
-    expect(second.elseElement, isNull);
-  }
-
-  void test_mapLiteral_spread() {
-    var map = parseCollectionLiteral('{1: 2, ...{3: 4}}') as SetOrMapLiteral;
-    expect(map.constKeyword, isNull);
-    expect(map.typeArguments, isNull);
-    expect(map.elements, hasLength(2));
-
-    var element = map.elements[1] as SpreadElement;
-    expect(element.spreadOperator.lexeme, '...');
-    var spreadExpression = element.expression as SetOrMapLiteral;
-    expect(spreadExpression.elements, hasLength(1));
-  }
-
-  void test_mapLiteral_spread2_typed() {
-    var map = parseCollectionLiteral('<int, int>{1: 2, ...{3: 4}}')
-        as SetOrMapLiteral;
-    expect(map.constKeyword, isNull);
-    expect(map.typeArguments.arguments, hasLength(2));
-    expect(map.elements, hasLength(2));
-
-    var element = map.elements[1] as SpreadElement;
-    expect(element.spreadOperator.lexeme, '...');
-    var spreadExpression = element.expression as SetOrMapLiteral;
-    expect(spreadExpression.elements, hasLength(1));
-  }
-
-  void test_mapLiteral_spread_typed() {
-    var map =
-        parseCollectionLiteral('<int, int>{...{3: 4}}') as SetOrMapLiteral;
-    expect(map.constKeyword, isNull);
-    expect(map.typeArguments.arguments, hasLength(2));
-    expect(map.elements, hasLength(1));
-
-    var element = map.elements[0] as SpreadElement;
-    expect(element.spreadOperator.lexeme, '...');
-    var spreadExpression = element.expression as SetOrMapLiteral;
-    expect(spreadExpression.elements, hasLength(1));
-  }
-
-  void test_mapLiteral_spreadQ() {
-    var map = parseCollectionLiteral('{1: 2, ...?{3: 4}}') as SetOrMapLiteral;
-    expect(map.constKeyword, isNull);
-    expect(map.typeArguments, isNull);
-    expect(map.elements, hasLength(2));
-
-    var element = map.elements[1] as SpreadElement;
-    expect(element.spreadOperator.lexeme, '...?');
-    var spreadExpression = element.expression as SetOrMapLiteral;
-    expect(spreadExpression.elements, hasLength(1));
-  }
-
-  void test_mapLiteral_spreadQ2_typed() {
-    var map = parseCollectionLiteral('<int, int>{1: 2, ...?{3: 4}}')
-        as SetOrMapLiteral;
-    expect(map.constKeyword, isNull);
-    expect(map.typeArguments.arguments, hasLength(2));
-    expect(map.elements, hasLength(2));
-
-    var element = map.elements[1] as SpreadElement;
-    expect(element.spreadOperator.lexeme, '...?');
-    var spreadExpression = element.expression as SetOrMapLiteral;
-    expect(spreadExpression.elements, hasLength(1));
-  }
-
-  void test_mapLiteral_spreadQ_typed() {
-    var map =
-        parseCollectionLiteral('<int, int>{...?{3: 4}}') as SetOrMapLiteral;
-    expect(map.constKeyword, isNull);
-    expect(map.typeArguments.arguments, hasLength(2));
-    expect(map.elements, hasLength(1));
-
-    var element = map.elements[0] as SpreadElement;
-    expect(element.spreadOperator.lexeme, '...?');
-    var spreadExpression = element.expression as SetOrMapLiteral;
-    expect(spreadExpression.elements, hasLength(1));
-  }
-
-  void test_setLiteral_if() {
-    var setLiteral =
-        parseCollectionLiteral('{1, if (true) 2}') as SetOrMapLiteral;
-    expect(setLiteral.elements, hasLength(2));
-    var first = setLiteral.elements[0] as IntegerLiteral;
-    expect(first.value, 1);
-
-    var second = setLiteral.elements[1] as IfElement;
-    var condition = second.condition as BooleanLiteral;
-    expect(condition.value, isTrue);
-    var thenElement = second.thenElement as IntegerLiteral;
-    expect(thenElement.value, 2);
-    expect(second.elseElement, isNull);
-  }
-
-  void test_setLiteral_ifElse() {
-    var setLiteral =
-        parseCollectionLiteral('{1, if (true) 2 else 5}') as SetOrMapLiteral;
-    expect(setLiteral.elements, hasLength(2));
-    var first = setLiteral.elements[0] as IntegerLiteral;
-    expect(first.value, 1);
-
-    var second = setLiteral.elements[1] as IfElement;
-    var condition = second.condition as BooleanLiteral;
-    expect(condition.value, isTrue);
-    var thenElement = second.thenElement as IntegerLiteral;
-    expect(thenElement.value, 2);
-    var elseElement = second.elseElement as IntegerLiteral;
-    expect(elseElement.value, 5);
-  }
-
-  void test_setLiteral_ifElseSpread() {
-    var setLiteral =
-        parseCollectionLiteral('{1, if (true) ...{2} else ...?[5]}')
-            as SetOrMapLiteral;
-    expect(setLiteral.elements, hasLength(2));
-    var first = setLiteral.elements[0] as IntegerLiteral;
-    expect(first.value, 1);
-
-    var second = setLiteral.elements[1] as IfElement;
-    var condition = second.condition as BooleanLiteral;
-    expect(condition.value, isTrue);
-    var thenElement = second.thenElement as SpreadElement;
-    expect(thenElement.spreadOperator.lexeme, '...');
-    var theExpression = thenElement.expression as SetOrMapLiteral;
-    expect(theExpression.elements, hasLength(1));
-    var elseElement = second.elseElement as SpreadElement;
-    expect(elseElement.spreadOperator.lexeme, '...?');
-    var elseExpression = elseElement.expression as ListLiteral;
-    expect(elseExpression.elements, hasLength(1));
-  }
-
-  void test_setLiteral_ifSpread() {
-    var setLiteral =
-        parseCollectionLiteral('{1, if (true) ...[2]}') as SetOrMapLiteral;
-    expect(setLiteral.elements, hasLength(2));
-    var first = setLiteral.elements[0] as IntegerLiteral;
-    expect(first.value, 1);
-
-    var second = setLiteral.elements[1] as IfElement;
-    var condition = second.condition as BooleanLiteral;
-    expect(condition.value, isTrue);
-    var thenElement = second.thenElement as SpreadElement;
-    expect(thenElement.spreadOperator.lexeme, '...');
-    expect(second.elseElement, isNull);
-  }
-
-  void test_setLiteral_spread2() {
-    var set = parseCollectionLiteral('{3, ...[4]}') as SetOrMapLiteral;
-    expect(set.constKeyword, isNull);
-    expect(set.typeArguments, isNull);
-    expect(set.elements, hasLength(2));
-    var value = set.elements[0] as IntegerLiteral;
-    expect(value.value, 3);
-
-    var element = set.elements[1] as SpreadElement;
-    expect(element.spreadOperator.lexeme, '...');
-    var spreadExpression = element.expression as ListLiteral;
-    expect(spreadExpression.elements, hasLength(1));
-  }
-
-  void test_setLiteral_spread2Q() {
-    var set = parseCollectionLiteral('{3, ...?[4]}') as SetOrMapLiteral;
-    expect(set.constKeyword, isNull);
-    expect(set.typeArguments, isNull);
-    expect(set.elements, hasLength(2));
-    var value = set.elements[0] as IntegerLiteral;
-    expect(value.value, 3);
-
-    var element = set.elements[1] as SpreadElement;
-    expect(element.spreadOperator.lexeme, '...?');
-    var spreadExpression = element.expression as ListLiteral;
-    expect(spreadExpression.elements, hasLength(1));
-  }
-
-  void test_setLiteral_spread_typed() {
-    var set = parseCollectionLiteral('<int>{...[3]}') as SetOrMapLiteral;
-    expect(set.constKeyword, isNull);
-    expect(set.typeArguments, isNotNull);
-    expect(set.elements, hasLength(1));
-
-    var element = set.elements[0] as SpreadElement;
-    expect(element.spreadOperator.lexeme, '...');
-    var spreadExpression = element.expression as ListLiteral;
-    expect(spreadExpression.elements, hasLength(1));
-  }
-
-  void test_setLiteral_spreadQ_typed() {
-    var set = parseCollectionLiteral('<int>{...?[3]}') as SetOrMapLiteral;
-    expect(set.constKeyword, isNull);
-    expect(set.typeArguments, isNotNull);
-    expect(set.elements, hasLength(1));
-
-    var element = set.elements[0] as SpreadElement;
-    expect(element.spreadOperator.lexeme, '...?');
-    var spreadExpression = element.expression as ListLiteral;
-    expect(spreadExpression.elements, hasLength(1));
-  }
-
-  void test_setOrMapLiteral_spread() {
-    var map = parseCollectionLiteral('{...{3: 4}}') as SetOrMapLiteral;
-    expect(map.constKeyword, isNull);
-    expect(map.typeArguments, isNull);
-    expect(map.elements, hasLength(1));
-
-    var element = map.elements[0] as SpreadElement;
-    expect(element.spreadOperator.lexeme, '...');
-    var spreadExpression = element.expression as SetOrMapLiteral;
-    expect(spreadExpression.elements, hasLength(1));
-  }
-
-  void test_setOrMapLiteral_spreadQ() {
-    var map = parseCollectionLiteral('{...?{3: 4}}') as SetOrMapLiteral;
-    expect(map.constKeyword, isNull);
-    expect(map.typeArguments, isNull);
-    expect(map.elements, hasLength(1));
-
-    var element = map.elements[0] as SpreadElement;
-    expect(element.spreadOperator.lexeme, '...?');
-    var spreadExpression = element.expression as SetOrMapLiteral;
-    expect(spreadExpression.elements, hasLength(1));
-  }
-}
-
-/// Tests of the fasta parser based on [ComplexParserTestMixin].
-@reflectiveTest
-class NNBDParserTest_Fasta extends FastaParserTestCase {
-  @override
-  CompilationUnit parseCompilationUnit(String content,
-          {List<ErrorCode> codes,
-          List<ExpectedError> errors,
-          FeatureSet featureSet}) =>
-      super.parseCompilationUnit(content,
-          codes: codes,
-          errors: errors,
-          featureSet: featureSet ?? FeatureSet.latestLanguageVersion());
-
-  void test_assignment_complex() {
-    parseCompilationUnit('D? foo(X? x) { X? x1; X? x2 = x + bar(7); }');
-  }
-
-  void test_assignment_complex2() {
-    parseCompilationUnit(r'''
-main() {
-  A? a;
-  String? s = '';
-  a?..foo().length..x27 = s!..toString().length;
-}
-''');
-  }
-
-  void test_assignment_simple() {
-    parseCompilationUnit('D? foo(X? x) { X? x1; X? x2 = x; }');
-  }
-
-  void test_bangBeforeFuctionCall1() {
-    // https://github.com/dart-lang/sdk/issues/39776
-    var unit = parseCompilationUnit('f() { Function? f1; f1!(42); }');
-    var funct = unit.declarations[0] as FunctionDeclaration;
-    var body = funct.functionExpression.body as BlockFunctionBody;
-    var statement1 = body.block.statements[0] as VariableDeclarationStatement;
-    expect(statement1.toSource(), "Function? f1;");
-    var statement2 = body.block.statements[1] as ExpressionStatement;
-
-    // expression is "f1!(42)"
-    var expression = statement2.expression as FunctionExpressionInvocation;
-    expect(expression.toSource(), "f1!(42)");
-
-    var functionExpression = expression.function as PostfixExpression;
-    SimpleIdentifier identifier = functionExpression.operand;
-    expect(identifier.name, 'f1');
-    expect(functionExpression.operator.lexeme, '!');
-
-    expect(expression.typeArguments, null);
-
-    expect(expression.argumentList.arguments.length, 1);
-    IntegerLiteral argument = expression.argumentList.arguments.single;
-    expect(argument.value, 42);
-  }
-
-  void test_bangBeforeFuctionCall2() {
-    // https://github.com/dart-lang/sdk/issues/39776
-    var unit = parseCompilationUnit('f() { Function f2; f2!<int>(42); }');
-    var funct = unit.declarations[0] as FunctionDeclaration;
-    var body = funct.functionExpression.body as BlockFunctionBody;
-    var statement1 = body.block.statements[0] as VariableDeclarationStatement;
-    expect(statement1.toSource(), "Function f2;");
-    var statement2 = body.block.statements[1] as ExpressionStatement;
-
-    // expression is "f2!<int>(42)"
-    var expression = statement2.expression as FunctionExpressionInvocation;
-    expect(expression.toSource(), "f2!<int>(42)");
-
-    var functionExpression = expression.function as PostfixExpression;
-    SimpleIdentifier identifier = functionExpression.operand;
-    expect(identifier.name, 'f2');
-    expect(functionExpression.operator.lexeme, '!');
-
-    expect(expression.typeArguments.arguments.length, 1);
-    TypeName typeArgument = expression.typeArguments.arguments.single;
-    expect(typeArgument.name.name, "int");
-
-    expect(expression.argumentList.arguments.length, 1);
-    IntegerLiteral argument = expression.argumentList.arguments.single;
-    expect(argument.value, 42);
-  }
-
-  void test_bangQuestionIndex() {
-    // http://dartbug.com/41177
-    CompilationUnit unit = parseCompilationUnit('f(dynamic a) { a!?[0]; }');
-    FunctionDeclaration funct = unit.declarations[0];
-    BlockFunctionBody body = funct.functionExpression.body;
-
-    ExpressionStatement statement = body.block.statements[0];
-    IndexExpression expression = statement.expression;
-
-    IntegerLiteral index = expression.index;
-    expect(index.value, 0);
-
-    Token question = expression.question;
-    expect(question, isNotNull);
-    expect(question.lexeme, "?");
-
-    PostfixExpression target = expression.target;
-    SimpleIdentifier identifier = target.operand;
-    expect(identifier.name, 'a');
-    expect(target.operator.lexeme, '!');
-  }
-
-  void test_binary_expression_statement() {
-    final unit = parseCompilationUnit('D? foo(X? x) { X ?? x2; }');
-    FunctionDeclaration funct = unit.declarations[0];
-    BlockFunctionBody body = funct.functionExpression.body;
-    ExpressionStatement statement = body.block.statements[0];
-    BinaryExpression expression = statement.expression;
-    SimpleIdentifier lhs = expression.leftOperand;
-    expect(lhs.name, 'X');
-    expect(expression.operator.lexeme, '??');
-    SimpleIdentifier rhs = expression.rightOperand;
-    expect(rhs.name, 'x2');
-  }
-
-  void test_cascade_withNullCheck_indexExpression() {
-    var unit = parseCompilationUnit('main() { a?..[27]; }');
-    FunctionDeclaration funct = unit.declarations[0];
-    BlockFunctionBody body = funct.functionExpression.body;
-    ExpressionStatement statement = body.block.statements[0];
-    CascadeExpression cascade = statement.expression;
-    IndexExpression indexExpression = cascade.cascadeSections[0];
-    expect(indexExpression.period.lexeme, '?..');
-    expect(indexExpression.toSource(), '?..[27]');
-  }
-
-  void test_cascade_withNullCheck_invalid() {
-    parseCompilationUnit('main() { a..[27]?..x; }', errors: [
-      expectedError(ParserErrorCode.NULL_AWARE_CASCADE_OUT_OF_ORDER, 16, 3),
-    ]);
-  }
-
-  void test_cascade_withNullCheck_methodInvocation() {
-    var unit = parseCompilationUnit('main() { a?..foo(); }');
-    FunctionDeclaration funct = unit.declarations[0];
-    BlockFunctionBody body = funct.functionExpression.body;
-    ExpressionStatement statement = body.block.statements[0];
-    CascadeExpression cascade = statement.expression;
-    MethodInvocation invocation = cascade.cascadeSections[0];
-    expect(invocation.operator.lexeme, '?..');
-    expect(invocation.toSource(), '?..foo()');
-  }
-
-  void test_cascade_withNullCheck_propertyAccess() {
-    var unit = parseCompilationUnit('main() { a?..x27; }');
-    FunctionDeclaration funct = unit.declarations[0];
-    BlockFunctionBody body = funct.functionExpression.body;
-    ExpressionStatement statement = body.block.statements[0];
-    CascadeExpression cascade = statement.expression;
-    PropertyAccess propertyAccess = cascade.cascadeSections[0];
-    expect(propertyAccess.operator.lexeme, '?..');
-    expect(propertyAccess.toSource(), '?..x27');
-  }
-
-  void test_conditional() {
-    parseCompilationUnit('D? foo(X? x) { X ? 7 : y; }');
-  }
-
-  void test_conditional_complex() {
-    parseCompilationUnit('D? foo(X? x) { X ? x2 = x + bar(7) : y; }');
-  }
-
-  void test_conditional_error() {
-    parseCompilationUnit('D? foo(X? x) { X ? ? x2 = x + bar(7) : y; }',
-        errors: [
-          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 19, 1),
-          expectedError(ParserErrorCode.EXPECTED_TOKEN, 40, 1),
-          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 40, 1),
-        ]);
-  }
-
-  void test_conditional_simple() {
-    parseCompilationUnit('D? foo(X? x) { X ? x2 = x : y; }');
-  }
-
-  void test_enableNonNullable_false() {
-    parseCompilationUnit('main() { x is String? ? (x + y) : z; }',
-        errors: [expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 20, 1)],
-        featureSet: preNonNullable);
-  }
-
-  void test_for() {
-    parseCompilationUnit('main() { for(int x = 0; x < 7; ++x) { } }');
-  }
-
-  void test_for_conditional() {
-    parseCompilationUnit('main() { for(x ? y = 7 : y = 8; y < 10; ++y) { } }');
-  }
-
-  void test_for_nullable() {
-    parseCompilationUnit('main() { for(int? x = 0; x < 7; ++x) { } }');
-  }
-
-  void test_foreach() {
-    parseCompilationUnit('main() { for(int x in [7]) { } }');
-  }
-
-  void test_foreach_nullable() {
-    parseCompilationUnit('main() { for(int? x in [7, null]) { } }');
-  }
-
-  void test_functionTypedFormalParameter_nullable_disabled() {
-    parseCompilationUnit('void f(void p()?) {}',
-        errors: [expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 15, 1)],
-        featureSet: preNonNullable);
-  }
-
-  test_fuzz_38113() async {
-    // https://github.com/dart-lang/sdk/issues/38113
-    parseCompilationUnit(r'+t{{r?this}}', errors: [
-      expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 0, 1),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 1, 1),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 4),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 10, 1),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 10, 1),
-    ]);
-  }
-
-  void test_gft_nullable() {
-    parseCompilationUnit('main() { C? Function() x = 7; }');
-  }
-
-  void test_gft_nullable_1() {
-    parseCompilationUnit('main() { C Function()? x = 7; }');
-  }
-
-  void test_gft_nullable_2() {
-    parseCompilationUnit('main() { C? Function()? x = 7; }');
-  }
-
-  void test_gft_nullable_3() {
-    parseCompilationUnit('main() { C? Function()? Function()? x = 7; }');
-  }
-
-  void test_gft_nullable_prefixed() {
-    parseCompilationUnit('main() { C.a? Function()? x = 7; }');
-  }
-
-  void test_indexed() {
-    CompilationUnit unit = parseCompilationUnit('main() { a[7]; }');
-    FunctionDeclaration method = unit.declarations[0];
-    BlockFunctionBody body = method.functionExpression.body;
-    ExpressionStatement statement = body.block.statements[0];
-    IndexExpression expression = statement.expression;
-    expect(expression.leftBracket.lexeme, '[');
-  }
-
-  void test_indexed_nullAware() {
-    CompilationUnit unit = parseCompilationUnit('main() { a?[7]; }');
-    FunctionDeclaration method = unit.declarations[0];
-    BlockFunctionBody body = method.functionExpression.body;
-    ExpressionStatement statement = body.block.statements[0];
-    IndexExpression expression = statement.expression;
-    expect(expression.question, isNotNull);
-    expect(expression.leftBracket.lexeme, '[');
-    expect(expression.rightBracket.lexeme, ']');
-    expect(expression.leftBracket.endGroup, expression.rightBracket);
-  }
-
-  void test_indexed_nullAware_optOut() {
-    CompilationUnit unit = parseCompilationUnit('''
-// @dart = 2.2
-main() { a?[7]; }''',
-        errors: [expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 25, 1)]);
-    FunctionDeclaration method = unit.declarations[0];
-    BlockFunctionBody body = method.functionExpression.body;
-    ExpressionStatement statement = body.block.statements[0];
-    IndexExpressionImpl expression = statement.expression;
-    expect(expression.target.toSource(), 'a');
-    expect(expression.question, isNotNull);
-    expect(expression.leftBracket.lexeme, '[');
-    expect(expression.rightBracket.lexeme, ']');
-    expect(expression.leftBracket.endGroup, expression.rightBracket);
-  }
-
-  void test_indexExpression_nullable_disabled() {
-    parseCompilationUnit('main(a) { a?[0]; }',
-        errors: [expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 11, 1)],
-        featureSet: preNonNullable);
-  }
-
-  void test_is_nullable() {
-    CompilationUnit unit =
-        parseCompilationUnit('main() { x is String? ? (x + y) : z; }');
-    FunctionDeclaration function = unit.declarations[0];
-    BlockFunctionBody body = function.functionExpression.body;
-    ExpressionStatement statement = body.block.statements[0];
-    ConditionalExpression expression = statement.expression;
-
-    IsExpression condition = expression.condition;
-    expect((condition.type as NamedType).question, isNotNull);
-    Expression thenExpression = expression.thenExpression;
-    expect(thenExpression, isParenthesizedExpression);
-    Expression elseExpression = expression.elseExpression;
-    expect(elseExpression, isSimpleIdentifier);
-  }
-
-  void test_is_nullable_parenthesis() {
-    CompilationUnit unit =
-        parseCompilationUnit('main() { (x is String?) ? (x + y) : z; }');
-    FunctionDeclaration function = unit.declarations[0];
-    BlockFunctionBody body = function.functionExpression.body;
-    ExpressionStatement statement = body.block.statements[0];
-    ConditionalExpression expression = statement.expression;
-
-    ParenthesizedExpression condition = expression.condition;
-    IsExpression isExpression = condition.expression;
-    expect((isExpression.type as NamedType).question, isNotNull);
-    Expression thenExpression = expression.thenExpression;
-    expect(thenExpression, isParenthesizedExpression);
-    Expression elseExpression = expression.elseExpression;
-    expect(elseExpression, isSimpleIdentifier);
-  }
-
-  void test_is_nullable_parenthesis_optOut() {
-    parseCompilationUnit('''
-// @dart = 2.2
-main() { (x is String?) ? (x + y) : z; }
-''', errors: [expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 36, 1)]);
-  }
-
-  void test_late_as_identifier() {
-    parseCompilationUnit('''
-class C {
-  int late;
-}
-
-void f(C c) {
-  print(c.late);
-}
-
-main() {
-  f(new C());
-}
-''', featureSet: preNonNullable);
-  }
-
-  void test_late_as_identifier_optOut() {
-    parseCompilationUnit('''
-// @dart = 2.2
-class C {
-  int late;
-}
-
-void f(C c) {
-  print(c.late);
-}
-
-main() {
-  f(new C());
-}
-''');
-  }
-
-  void test_nullableTypeInInitializerList_01() {
-    // http://dartbug.com/40834
-    var unit = parseCompilationUnit(r'''
-class Foo {
-  String? x;
-  int y;
-
-  Foo(Object? o) : x = o as String?, y = 0;
-}
-''');
-    ClassDeclaration classDeclaration = unit.declarations.first;
-    ConstructorDeclaration constructor = classDeclaration.getConstructor(null);
-
-    // Object? o
-    SimpleFormalParameter parameter = constructor.parameters.parameters.single;
-    expect(parameter.identifier.name, 'o');
-    TypeName type = parameter.type;
-    expect(type.question.lexeme, '?');
-    expect(type.name.name, 'Object');
-
-    expect(constructor.initializers.length, 2);
-
-    // o as String?
-    {
-      ConstructorFieldInitializer initializer = constructor.initializers[0];
-      expect(initializer.fieldName.name, 'x');
-      AsExpression expression = initializer.expression;
-      SimpleIdentifier identifier = expression.expression;
-      expect(identifier.name, 'o');
-      TypeName expressionType = expression.type;
-      expect(expressionType.question.lexeme, '?');
-      expect(expressionType.name.name, 'String');
-    }
-
-    // y = 0
-    {
-      ConstructorFieldInitializer initializer = constructor.initializers[1];
-      expect(initializer.fieldName.name, 'y');
-      IntegerLiteral expression = initializer.expression;
-      expect(expression.value, 0);
-    }
-  }
-
-  void test_nullableTypeInInitializerList_02() {
-    var unit = parseCompilationUnit(r'''
-class Foo {
-  String? x;
-  int y;
-
-  Foo(Object? o) : y = o is String? ? o.length : null, x = null;
-}
-''');
-    ClassDeclaration classDeclaration = unit.declarations.first;
-    ConstructorDeclaration constructor = classDeclaration.getConstructor(null);
-
-    // Object? o
-    SimpleFormalParameter parameter = constructor.parameters.parameters.single;
-    expect(parameter.identifier.name, 'o');
-    TypeName type = parameter.type;
-    expect(type.question.lexeme, '?');
-    expect(type.name.name, 'Object');
-
-    expect(constructor.initializers.length, 2);
-
-    // y = o is String? ? o.length : null
-    {
-      ConstructorFieldInitializer initializer = constructor.initializers[0];
-      expect(initializer.fieldName.name, 'y');
-      ConditionalExpression expression = initializer.expression;
-      IsExpression condition = expression.condition;
-      SimpleIdentifier identifier = condition.expression;
-      expect(identifier.name, 'o');
-      TypeName expressionType = condition.type;
-      expect(expressionType.question.lexeme, '?');
-      expect(expressionType.name.name, 'String');
-      PrefixedIdentifier thenExpression = expression.thenExpression;
-      expect(thenExpression.identifier.name, 'length');
-      expect(thenExpression.prefix.name, 'o');
-      NullLiteral elseExpression = expression.elseExpression;
-      expect(elseExpression, isNotNull);
-    }
-
-    // x = null
-    {
-      ConstructorFieldInitializer initializer = constructor.initializers[1];
-      expect(initializer.fieldName.name, 'x');
-      NullLiteral expression = initializer.expression;
-      expect(expression, isNotNull);
-    }
-  }
-
-  void test_nullableTypeInInitializerList_03() {
-    // As test_nullableTypeInInitializerList_02 but without ? on String in is.
-    var unit = parseCompilationUnit(r'''
-class Foo {
-  String? x;
-  int y;
-
-  Foo(Object? o) : y = o is String ? o.length : null, x = null;
-}
-''');
-    ClassDeclaration classDeclaration = unit.declarations.first;
-    ConstructorDeclaration constructor = classDeclaration.getConstructor(null);
-
-    // Object? o
-    SimpleFormalParameter parameter = constructor.parameters.parameters.single;
-    expect(parameter.identifier.name, 'o');
-    TypeName type = parameter.type;
-    expect(type.question.lexeme, '?');
-    expect(type.name.name, 'Object');
-
-    expect(constructor.initializers.length, 2);
-
-    // y = o is String ? o.length : null
-    {
-      ConstructorFieldInitializer initializer = constructor.initializers[0];
-      expect(initializer.fieldName.name, 'y');
-      ConditionalExpression expression = initializer.expression;
-      IsExpression condition = expression.condition;
-      SimpleIdentifier identifier = condition.expression;
-      expect(identifier.name, 'o');
-      TypeName expressionType = condition.type;
-      expect(expressionType.question, isNull);
-      expect(expressionType.name.name, 'String');
-      PrefixedIdentifier thenExpression = expression.thenExpression;
-      expect(thenExpression.identifier.name, 'length');
-      expect(thenExpression.prefix.name, 'o');
-      NullLiteral elseExpression = expression.elseExpression;
-      expect(elseExpression, isNotNull);
-    }
-
-    // x = null
-    {
-      ConstructorFieldInitializer initializer = constructor.initializers[1];
-      expect(initializer.fieldName.name, 'x');
-      NullLiteral expression = initializer.expression;
-      expect(expression, isNotNull);
-    }
-  }
-
-  void test_nullCheck() {
-    var unit = parseCompilationUnit('f(int? y) { var x = y!; }');
-    FunctionDeclaration function = unit.declarations[0];
-    BlockFunctionBody body = function.functionExpression.body;
-    VariableDeclarationStatement statement = body.block.statements[0];
-    PostfixExpression expression = statement.variables.variables[0].initializer;
-    SimpleIdentifier identifier = expression.operand;
-    expect(identifier.name, 'y');
-    expect(expression.operator.lexeme, '!');
-  }
-
-  void test_nullCheck_disabled() {
-    var unit = parseCompilationUnit('f(int? y) { var x = y!; }',
-        errors: [
-          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 5, 1),
-          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 21, 1),
-        ],
-        featureSet: preNonNullable);
-    FunctionDeclaration function = unit.declarations[0];
-    BlockFunctionBody body = function.functionExpression.body;
-    VariableDeclarationStatement statement = body.block.statements[0];
-    SimpleIdentifier identifier = statement.variables.variables[0].initializer;
-    expect(identifier.name, 'y');
-  }
-
-  void test_nullCheckAfterGetterAccess() {
-    parseCompilationUnit('f() { var x = g.x!.y + 7; }');
-  }
-
-  void test_nullCheckAfterMethodCall() {
-    parseCompilationUnit('f() { var x = g.m()!.y + 7; }');
-  }
-
-  void test_nullCheckBeforeGetterAccess() {
-    parseCompilationUnit('f() { var x = g!.x + 7; }');
-  }
-
-  void test_nullCheckBeforeIndex() {
-    // https://github.com/dart-lang/sdk/issues/37708
-    var unit = parseCompilationUnit('f() { foo.bar!.baz[arg]; }');
-    var funct = unit.declarations[0] as FunctionDeclaration;
-    var body = funct.functionExpression.body as BlockFunctionBody;
-    var statement = body.block.statements[0] as ExpressionStatement;
-    var expression = statement.expression as IndexExpression;
-    expect(expression.index.toSource(), 'arg');
-    var propertyAccess = expression.target as PropertyAccess;
-    expect(propertyAccess.propertyName.toSource(), 'baz');
-    var target = propertyAccess.target as PostfixExpression;
-    expect(target.operand.toSource(), 'foo.bar');
-    expect(target.operator.lexeme, '!');
-  }
-
-  void test_nullCheckBeforeMethodCall() {
-    parseCompilationUnit('f() { var x = g!.m() + 7; }');
-  }
-
-  void test_nullCheckFunctionResult() {
-    parseCompilationUnit('f() { var x = g()! + 7; }');
-  }
-
-  void test_nullCheckIndexedValue() {
-    parseCompilationUnit('f(int? y) { var x = y[0]! + 7; }');
-  }
-
-  void test_nullCheckIndexedValue2() {
-    parseCompilationUnit('f(int? y) { var x = super.y[0]! + 7; }');
-  }
-
-  void test_nullCheckInExpression() {
-    parseCompilationUnit('f(int? y) { var x = y! + 7; }');
-  }
-
-  void test_nullCheckInExpression_disabled() {
-    parseCompilationUnit('f(int? y) { var x = y! + 7; }',
-        errors: [
-          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 5, 1),
-          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 21, 1),
-        ],
-        featureSet: preNonNullable);
-  }
-
-  void test_nullCheckMethodResult() {
-    parseCompilationUnit('f() { var x = g.m()! + 7; }');
-  }
-
-  void test_nullCheckMethodResult2() {
-    parseCompilationUnit('f() { var x = g?.m()! + 7; }');
-  }
-
-  void test_nullCheckMethodResult3() {
-    parseCompilationUnit('f() { var x = super.m()! + 7; }');
-  }
-
-  void test_nullCheckOnConstConstructor() {
-    parseCompilationUnit('f() { var x = const Foo()!; }');
-  }
-
-  void test_nullCheckOnConstructor() {
-    parseCompilationUnit('f() { var x = new Foo()!; }');
-  }
-
-  void test_nullCheckOnIndex() {
-    // https://github.com/dart-lang/sdk/issues/37708
-    var unit = parseCompilationUnit('f() { obj![arg]; }');
-    var funct = unit.declarations[0] as FunctionDeclaration;
-    var body = funct.functionExpression.body as BlockFunctionBody;
-    var statement = body.block.statements[0] as ExpressionStatement;
-    var expression = statement.expression as IndexExpression;
-    var target = expression.target as PostfixExpression;
-    expect(target.operand.toSource(), 'obj');
-    expect(target.operator.lexeme, '!');
-  }
-
-  void test_nullCheckOnIndex2() {
-    // https://github.com/dart-lang/sdk/issues/37708
-    var unit = parseCompilationUnit('f() { obj![arg]![arg2]; }');
-    var funct = unit.declarations[0] as FunctionDeclaration;
-    var body = funct.functionExpression.body as BlockFunctionBody;
-    var statement = body.block.statements[0] as ExpressionStatement;
-    var expression = statement.expression as IndexExpression;
-    expect(expression.index.toSource(), 'arg2');
-    var target = expression.target as PostfixExpression;
-    expect(target.operator.lexeme, '!');
-    expression = target.operand as IndexExpression;
-    expect(expression.index.toSource(), 'arg');
-    target = expression.target as PostfixExpression;
-    expect(target.operator.lexeme, '!');
-    expect(target.operand.toSource(), 'obj');
-  }
-
-  void test_nullCheckOnIndex3() {
-    // https://github.com/dart-lang/sdk/issues/37708
-    var unit = parseCompilationUnit('f() { foo.bar![arg]; }');
-    var funct = unit.declarations[0] as FunctionDeclaration;
-    var body = funct.functionExpression.body as BlockFunctionBody;
-    var statement = body.block.statements[0] as ExpressionStatement;
-    var expression = statement.expression as IndexExpression;
-    expect(expression.index.toSource(), 'arg');
-    var target = expression.target as PostfixExpression;
-    expect(target.operand.toSource(), 'foo.bar');
-    expect(target.operator.lexeme, '!');
-  }
-
-  void test_nullCheckOnIndex4() {
-    // https://github.com/dart-lang/sdk/issues/37708
-    var unit = parseCompilationUnit('f() { foo!.bar![arg]; }');
-    var funct = unit.declarations[0] as FunctionDeclaration;
-    var body = funct.functionExpression.body as BlockFunctionBody;
-    var statement = body.block.statements[0] as ExpressionStatement;
-    var expression = statement.expression as IndexExpression;
-    var fooBarTarget = expression.target as PostfixExpression;
-    expect(fooBarTarget.toSource(), "foo!.bar!");
-    var propertyAccess = fooBarTarget.operand as PropertyAccess;
-    var targetFoo = propertyAccess.target as PostfixExpression;
-    expect(targetFoo.operand.toSource(), "foo");
-    expect(targetFoo.operator.lexeme, "!");
-    expect(propertyAccess.propertyName.toSource(), "bar");
-    expect(fooBarTarget.operator.lexeme, '!');
-    expect(expression.index.toSource(), 'arg');
-  }
-
-  void test_nullCheckOnIndex5() {
-    // https://github.com/dart-lang/sdk/issues/37708
-    var unit = parseCompilationUnit('f() { foo.bar![arg]![arg2]; }');
-    var funct = unit.declarations[0] as FunctionDeclaration;
-    var body = funct.functionExpression.body as BlockFunctionBody;
-    var statement = body.block.statements[0] as ExpressionStatement;
-    var expression = statement.expression as IndexExpression;
-    expect(expression.index.toSource(), 'arg2');
-    var target = expression.target as PostfixExpression;
-    expect(target.operator.lexeme, '!');
-    expression = target.operand as IndexExpression;
-    expect(expression.index.toSource(), 'arg');
-    target = expression.target as PostfixExpression;
-    expect(target.operator.lexeme, '!');
-    expect(target.operand.toSource(), 'foo.bar');
-  }
-
-  void test_nullCheckOnIndex6() {
-    // https://github.com/dart-lang/sdk/issues/37708
-    var unit = parseCompilationUnit('f() { foo!.bar![arg]![arg2]; }');
-    var funct = unit.declarations[0] as FunctionDeclaration;
-    var body = funct.functionExpression.body as BlockFunctionBody;
-    var statement = body.block.statements[0] as ExpressionStatement;
-
-    // expression is "foo!.bar![arg]![arg2]"
-    var expression = statement.expression as IndexExpression;
-    expect(expression.index.toSource(), 'arg2');
-
-    // target is "foo!.bar![arg]!"
-    var target = expression.target as PostfixExpression;
-    expect(target.operator.lexeme, '!');
-
-    // expression is "foo!.bar![arg]"
-    expression = target.operand as IndexExpression;
-    expect(expression.index.toSource(), 'arg');
-
-    // target is "foo!.bar!"
-    target = expression.target as PostfixExpression;
-    expect(target.operator.lexeme, '!');
-
-    // propertyAccess is "foo!.bar"
-    PropertyAccess propertyAccess = target.operand as PropertyAccess;
-    expect(propertyAccess.propertyName.toSource(), "bar");
-
-    // target is "foo!"
-    target = propertyAccess.target as PostfixExpression;
-    expect(target.operator.lexeme, '!');
-
-    expect(target.operand.toSource(), "foo");
-  }
-
-  void test_nullCheckOnLiteral_disabled() {
-    parseCompilationUnit('f() { var x = 0!; }',
-        errors: [expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 15, 1)],
-        featureSet: preNonNullable);
-  }
-
-  void test_nullCheckOnLiteralDouble() {
-    // Issues like this should be caught during later analysis
-    parseCompilationUnit('f() { var x = 1.2!; }');
-  }
-
-  void test_nullCheckOnLiteralInt() {
-    // Issues like this should be caught during later analysis
-    parseCompilationUnit('f() { var x = 0!; }');
-  }
-
-  void test_nullCheckOnLiteralList() {
-    // Issues like this should be caught during later analysis
-    parseCompilationUnit('f() { var x = [1,2]!; }');
-  }
-
-  void test_nullCheckOnLiteralMap() {
-    // Issues like this should be caught during later analysis
-    parseCompilationUnit('f() { var x = {1:2}!; }');
-  }
-
-  void test_nullCheckOnLiteralSet() {
-    // Issues like this should be caught during later analysis
-    parseCompilationUnit('f() { var x = {1,2}!; }');
-  }
-
-  void test_nullCheckOnLiteralString() {
-    // Issues like this should be caught during later analysis
-    parseCompilationUnit('f() { var x = "seven"!; }');
-  }
-
-  void test_nullCheckOnNull() {
-    // Issues like this should be caught during later analysis
-    parseCompilationUnit('f() { var x = null!; }');
-  }
-
-  void test_nullCheckOnSend() {
-    // https://github.com/dart-lang/sdk/issues/37708
-    var unit = parseCompilationUnit('f() { obj!(arg); }');
-    var funct = unit.declarations[0] as FunctionDeclaration;
-    var body = funct.functionExpression.body as BlockFunctionBody;
-    var statement = body.block.statements[0] as ExpressionStatement;
-    var expression = statement.expression as FunctionExpressionInvocation;
-    var target = expression.function as PostfixExpression;
-    expect(target.operand.toSource(), 'obj');
-    expect(target.operator.lexeme, '!');
-  }
-
-  void test_nullCheckOnSend2() {
-    // https://github.com/dart-lang/sdk/issues/37708
-    var unit = parseCompilationUnit('f() { obj!(arg)!(arg2); }');
-    var funct = unit.declarations[0] as FunctionDeclaration;
-    var body = funct.functionExpression.body as BlockFunctionBody;
-    var statement = body.block.statements[0] as ExpressionStatement;
-    var expression = statement.expression as FunctionExpressionInvocation;
-    expect(expression.argumentList.toSource(), '(arg2)');
-    var target = expression.function as PostfixExpression;
-    expect(target.operator.lexeme, '!');
-    expression = target.operand as FunctionExpressionInvocation;
-    expect(expression.argumentList.toSource(), '(arg)');
-    target = expression.function as PostfixExpression;
-    expect(target.operator.lexeme, '!');
-    expect(target.operand.toSource(), 'obj');
-  }
-
-  void test_nullCheckOnSymbol() {
-    // Issues like this should be caught during later analysis
-    parseCompilationUnit('f() { var x = #seven!; }');
-  }
-
-  void test_nullCheckOnValue() {
-    parseCompilationUnit('f(Point p) { var x = p.y! + 7; }');
-  }
-
-  void test_nullCheckOnValue_disabled() {
-    parseCompilationUnit('f(Point p) { var x = p.y! + 7; }',
-        errors: [expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 24, 1)],
-        featureSet: preNonNullable);
-  }
-
-  void test_nullCheckParenthesizedExpression() {
-    parseCompilationUnit('f(int? y) { var x = (y)! + 7; }');
-  }
-
-  void test_nullCheckPropertyAccess() {
-    parseCompilationUnit('f() { var x = g.p! + 7; }');
-  }
-
-  void test_nullCheckPropertyAccess2() {
-    parseCompilationUnit('f() { var x = g?.p! + 7; }');
-  }
-
-  void test_nullCheckPropertyAccess3() {
-    parseCompilationUnit('f() { var x = super.p! + 7; }');
-  }
-
-  void test_postfix_null_assertion_and_unary_prefix_operator_precedence() {
-    // -x! is parsed as -(x!).
-    var unit = parseCompilationUnit('void main() { -x!; }');
-    var function = unit.declarations[0] as FunctionDeclaration;
-    var body = function.functionExpression.body as BlockFunctionBody;
-    var statement = body.block.statements[0] as ExpressionStatement;
-    var outerExpression = statement.expression as PrefixExpression;
-    expect(outerExpression.operator.type, TokenType.MINUS);
-    var innerExpression = outerExpression.operand as PostfixExpression;
-    expect(innerExpression.operator.type, TokenType.BANG);
-  }
-
-  void test_postfix_null_assertion_of_postfix_expression() {
-    // x++! is parsed as (x++)!.
-    var unit = parseCompilationUnit('void main() { x++!; }');
-    var function = unit.declarations[0] as FunctionDeclaration;
-    var body = function.functionExpression.body as BlockFunctionBody;
-    var statement = body.block.statements[0] as ExpressionStatement;
-    var outerExpression = statement.expression as PostfixExpression;
-    expect(outerExpression.operator.type, TokenType.BANG);
-    var innerExpression = outerExpression.operand as PostfixExpression;
-    expect(innerExpression.operator.type, TokenType.PLUS_PLUS);
-  }
-
-  void test_typeName_nullable_disabled() {
-    parseCompilationUnit('int? x;',
-        errors: [expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 3, 1)],
-        featureSet: preNonNullable);
-  }
-}
-
-@reflectiveTest
-class RecoveryParserTest_Fasta extends FastaParserTestCase
-    with RecoveryParserTestMixin {
-  @override
-  void test_equalityExpression_precedence_relational_right() {
-    parseExpression("== is", codes: [
-      ParserErrorCode.EXPECTED_TYPE_NAME,
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-  }
-
-  void test_incompleteForEach2() {
-    ForStatement statement =
-        parseStatement('for (String item i) {}', featureSet: controlFlow);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 12, 4),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 17, 1)
-    ]);
-    expect(statement.toSource(), 'for (String item; i;) {}');
-    ForPartsWithDeclarations forLoopParts = statement.forLoopParts;
-    expect(forLoopParts.leftSeparator, isNotNull);
-    expect(forLoopParts.leftSeparator.type, TokenType.SEMICOLON);
-    expect(forLoopParts.rightSeparator, isNotNull);
-    expect(forLoopParts.rightSeparator.type, TokenType.SEMICOLON);
-  }
-
-  void test_invalidTypeParameters_super() {
-    parseCompilationUnit('class C<X super Y> {}', errors: [
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 8, 1),
-    ]);
-  }
-
-  @override
-  void test_relationalExpression_missing_LHS_RHS() {
-    parseExpression("is", codes: [
-      ParserErrorCode.EXPECTED_TYPE_NAME,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-  }
-
-  @override
-  void test_relationalExpression_precedence_shift_right() {
-    parseExpression("<< is", codes: [
-      ParserErrorCode.EXPECTED_TYPE_NAME,
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-  }
-}
-
-@reflectiveTest
-class SimpleParserTest_Fasta extends FastaParserTestCase
-    with SimpleParserTestMixin {
-  void test_method_name_notNull_37733() {
-    // https://github.com/dart-lang/sdk/issues/37733
-    var unit = parseCompilationUnit(r'class C { f(<T>()); }', errors: [
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 12, 1),
-    ]);
-    var classDeclaration = unit.declarations[0] as ClassDeclaration;
-    var method = classDeclaration.members[0] as MethodDeclaration;
-    expect(method.parameters.parameters, hasLength(1));
-    var parameter =
-        method.parameters.parameters[0] as FunctionTypedFormalParameter;
-    expect(parameter.identifier, isNotNull);
-  }
-
-  test_parseArgument() {
-    Expression result = parseArgument('3');
-    expect(result, const TypeMatcher<IntegerLiteral>());
-    IntegerLiteral literal = result;
-    expect(literal.value, 3);
-  }
-
-  test_parseArgument_named() {
-    Expression result = parseArgument('foo: "a"');
-    expect(result, const TypeMatcher<NamedExpression>());
-    NamedExpression expression = result;
-    StringLiteral literal = expression.expression;
-    expect(literal.stringValue, 'a');
-  }
-
-  @failingTest
-  @override
-  void test_parseCommentReferences_skipLink_direct_multiLine() =>
-      super.test_parseCommentReferences_skipLink_direct_multiLine();
-
-  @failingTest
-  @override
-  void test_parseCommentReferences_skipLink_reference_multiLine() =>
-      super.test_parseCommentReferences_skipLink_reference_multiLine();
-
-  void test_parseVariableDeclaration_final_late() {
-    var statement = parseStatement('final late a;', featureSet: nonNullable)
-        as VariableDeclarationStatement;
-    var declarationList = statement.variables;
-    assertErrors(
-        errors: [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 6, 4)]);
-    expect(declarationList.keyword.lexeme, 'final');
-    expect(declarationList.type, isNull);
-    expect(declarationList.variables, hasLength(1));
-  }
-
-  void test_parseVariableDeclaration_late() {
-    var statement = parseStatement('late a;', featureSet: nonNullable)
-        as VariableDeclarationStatement;
-    var declarationList = statement.variables;
-    assertErrors(errors: [
-      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 5, 1)
-    ]);
-    expect(declarationList.keyword, isNull);
-    expect(declarationList.type, isNull);
-    expect(declarationList.variables, hasLength(1));
-  }
-
-  void test_parseVariableDeclaration_late_final() {
-    var statement = parseStatement('late final a;', featureSet: nonNullable)
-        as VariableDeclarationStatement;
-    var declarationList = statement.variables;
-    assertNoErrors();
-    expect(declarationList.keyword.lexeme, 'final');
-    expect(declarationList.type, isNull);
-    expect(declarationList.variables, hasLength(1));
-  }
-
-  void test_parseVariableDeclaration_late_init() {
-    var statement = parseStatement('late a = 0;', featureSet: nonNullable)
-        as VariableDeclarationStatement;
-    var declarationList = statement.variables;
-    assertErrors(errors: [
-      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 5, 1)
-    ]);
-    expect(declarationList.keyword, isNull);
-    expect(declarationList.type, isNull);
-    expect(declarationList.variables, hasLength(1));
-  }
-
-  void test_parseVariableDeclaration_late_type() {
-    var statement = parseStatement('late A a;', featureSet: nonNullable)
-        as VariableDeclarationStatement;
-    var declarationList = statement.variables;
-    assertNoErrors();
-    expect(declarationList.lateKeyword, isNotNull);
-    expect(declarationList.keyword, isNull);
-    expect(declarationList.type, isNotNull);
-    expect(declarationList.variables, hasLength(1));
-  }
-
-  void test_parseVariableDeclaration_late_var() {
-    var statement = parseStatement('late var a;', featureSet: nonNullable)
-        as VariableDeclarationStatement;
-    var declarationList = statement.variables;
-    assertNoErrors();
-    expect(declarationList.lateKeyword, isNotNull);
-    expect(declarationList.keyword?.lexeme, 'var');
-    expect(declarationList.type, isNull);
-    expect(declarationList.variables, hasLength(1));
-  }
-
-  void test_parseVariableDeclaration_late_var_init() {
-    var statement = parseStatement('late var a = 0;', featureSet: nonNullable)
-        as VariableDeclarationStatement;
-    var declarationList = statement.variables;
-    assertNoErrors();
-    expect(declarationList.lateKeyword, isNotNull);
-    expect(declarationList.keyword?.lexeme, 'var');
-    expect(declarationList.type, isNull);
-    expect(declarationList.variables, hasLength(1));
-  }
-
-  void test_typeAlias_37733() {
-    // https://github.com/dart-lang/sdk/issues/37733
-    var unit = parseCompilationUnit(r'typedef K=Function(<>($', errors: [
-      expectedError(CompileTimeErrorCode.INVALID_INLINE_FUNCTION_TYPE, 19, 1),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 19, 1),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 20, 1),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 22, 1),
-      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 23, 1),
-      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 23, 1),
-    ]);
-    var typeAlias = unit.declarations[0] as GenericTypeAlias;
-    expect(typeAlias.name.toSource(), 'K');
-    var functionType = typeAlias.functionType;
-    expect(functionType.parameters.parameters, hasLength(1));
-    var parameter = functionType.parameters.parameters[0];
-    expect(parameter.identifier, isNotNull);
-  }
-
-  void test_typeAlias_parameter_missingIdentifier_37733() {
-    // https://github.com/dart-lang/sdk/issues/37733
-    var unit = parseCompilationUnit(r'typedef T=Function(<S>());', errors: [
-      expectedError(CompileTimeErrorCode.INVALID_INLINE_FUNCTION_TYPE, 19, 1),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 19, 1),
-    ]);
-    var typeAlias = unit.declarations[0] as GenericTypeAlias;
-    expect(typeAlias.name.toSource(), 'T');
-    var functionType = typeAlias.functionType;
-    expect(functionType.parameters.parameters, hasLength(1));
-    var parameter = functionType.parameters.parameters[0];
-    expect(parameter.identifier, isNotNull);
-  }
-}
-
-/// Tests of the fasta parser based on [StatementParserTestMixin].
-@reflectiveTest
-class StatementParserTest_Fasta extends FastaParserTestCase
-    with StatementParserTestMixin {
-  void test_35177() {
-    ExpressionStatement statement = parseStatement('(f)()<int>();');
-
-    FunctionExpressionInvocation funct1 = statement.expression;
-    NodeList<TypeAnnotation> typeArgs = funct1.typeArguments.arguments;
-    expect(typeArgs, hasLength(1));
-    TypeName typeName = typeArgs[0];
-    expect(typeName.name.name, 'int');
-    expect(funct1.argumentList.arguments, hasLength(0));
-
-    FunctionExpressionInvocation funct2 = funct1.function;
-    expect(funct2.typeArguments, isNull);
-    expect(funct2.argumentList.arguments, hasLength(0));
-
-    ParenthesizedExpression expression = funct2.function;
-    SimpleIdentifier identifier = expression.expression;
-    expect(identifier.name, 'f');
-  }
-
-  void test_invalid_typeArg_34850() {
-    var unit = parseCompilationUnit('foo Future<List<int>> bar() {}', errors: [
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 11, 4),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 4, 6),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 22, 3),
-    ]);
-    // Validate that recovery has properly updated the token stream.
-    analyzer.Token token = unit.beginToken;
-    while (!token.isEof) {
-      expect(token.type, isNot(TokenType.GT_GT));
-      analyzer.Token next = token.next;
-      expect(next.previous, token);
-      token = next;
-    }
-  }
-
-  void test_parseForStatement_each_await2() {
-    ForStatement forStatement = parseStatement(
-      'await for (element in list) {}',
-      inAsync: true,
-      featureSet: controlFlow,
-    );
-    assertNoErrors();
-    expect(forStatement.awaitKeyword, isNotNull);
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    ForEachPartsWithIdentifier forLoopParts = forStatement.forLoopParts;
-    expect(forLoopParts.identifier, isNotNull);
-    expect(forLoopParts.inKeyword, isNotNull);
-    expect(forLoopParts.iterable, isNotNull);
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_each_finalExternal() {
-    ForStatement forStatement = parseStatement(
-      'for (final external in list) {}',
-      featureSet: controlFlow,
-    );
-    assertNoErrors();
-    expect(forStatement.awaitKeyword, isNull);
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    ForEachPartsWithDeclaration forLoopParts = forStatement.forLoopParts;
-    expect(forLoopParts.loopVariable.identifier.name, 'external');
-    expect(forLoopParts.inKeyword, isNotNull);
-    expect(forLoopParts.iterable, isNotNull);
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_each_finalRequired() {
-    ForStatement forStatement = parseStatement(
-      'for (final required in list) {}',
-      featureSet: controlFlow,
-    );
-    assertNoErrors();
-    expect(forStatement.awaitKeyword, isNull);
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    ForEachPartsWithDeclaration forLoopParts = forStatement.forLoopParts;
-    expect(forLoopParts.loopVariable.identifier.name, 'required');
-    expect(forLoopParts.inKeyword, isNotNull);
-    expect(forLoopParts.iterable, isNotNull);
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_each_genericFunctionType2() {
-    ForStatement forStatement = parseStatement(
-      'for (void Function<T>(T) element in list) {}',
-      featureSet: controlFlow,
-    );
-    assertNoErrors();
-    expect(forStatement.awaitKeyword, isNull);
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    ForEachPartsWithDeclaration forLoopParts = forStatement.forLoopParts;
-    expect(forLoopParts.loopVariable, isNotNull);
-    expect(forLoopParts.inKeyword, isNotNull);
-    expect(forLoopParts.iterable, isNotNull);
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_each_identifier2() {
-    ForStatement forStatement = parseStatement(
-      'for (element in list) {}',
-      featureSet: controlFlow,
-    );
-    assertNoErrors();
-    expect(forStatement.awaitKeyword, isNull);
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    ForEachPartsWithIdentifier forLoopParts = forStatement.forLoopParts;
-    expect(forLoopParts.identifier, isNotNull);
-    expect(forLoopParts.inKeyword, isNotNull);
-    expect(forLoopParts.iterable, isNotNull);
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_each_noType_metadata2() {
-    ForStatement forStatement = parseStatement(
-      'for (@A var element in list) {}',
-      featureSet: controlFlow,
-    );
-    assertNoErrors();
-    expect(forStatement.awaitKeyword, isNull);
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    ForEachPartsWithDeclaration forLoopParts = forStatement.forLoopParts;
-    expect(forLoopParts.loopVariable, isNotNull);
-    expect(forLoopParts.loopVariable.metadata, hasLength(1));
-    expect(forLoopParts.inKeyword, isNotNull);
-    expect(forLoopParts.iterable, isNotNull);
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_each_type2() {
-    ForStatement forStatement = parseStatement(
-      'for (A element in list) {}',
-      featureSet: controlFlow,
-    );
-    assertNoErrors();
-    expect(forStatement.awaitKeyword, isNull);
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    ForEachPartsWithDeclaration forLoopParts = forStatement.forLoopParts;
-    expect(forLoopParts.loopVariable, isNotNull);
-    expect(forLoopParts.inKeyword, isNotNull);
-    expect(forLoopParts.iterable, isNotNull);
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_each_var2() {
-    ForStatement forStatement = parseStatement(
-      'for (var element in list) {}',
-      featureSet: controlFlow,
-    );
-    assertNoErrors();
-    expect(forStatement.awaitKeyword, isNull);
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    ForEachPartsWithDeclaration forLoopParts = forStatement.forLoopParts;
-    expect(forLoopParts.loopVariable, isNotNull);
-    expect(forLoopParts.inKeyword, isNotNull);
-    expect(forLoopParts.iterable, isNotNull);
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_loop_c2() {
-    ForStatement forStatement = parseStatement(
-      'for (; i < count;) {}',
-      featureSet: controlFlow,
-    );
-    assertNoErrors();
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    ForPartsWithExpression forLoopParts = forStatement.forLoopParts;
-    expect(forLoopParts.initialization, isNull);
-    expect(forLoopParts.leftSeparator, isNotNull);
-    expect(forLoopParts.condition, isNotNull);
-    expect(forLoopParts.rightSeparator, isNotNull);
-    expect(forLoopParts.updaters, hasLength(0));
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_loop_cu2() {
-    ForStatement forStatement = parseStatement(
-      'for (; i < count; i++) {}',
-      featureSet: controlFlow,
-    );
-    assertNoErrors();
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    ForPartsWithExpression forLoopParts = forStatement.forLoopParts;
-    expect(forLoopParts.initialization, isNull);
-    expect(forLoopParts.leftSeparator, isNotNull);
-    expect(forLoopParts.condition, isNotNull);
-    expect(forLoopParts.rightSeparator, isNotNull);
-    expect(forLoopParts.updaters, hasLength(1));
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_loop_ecu2() {
-    ForStatement forStatement = parseStatement(
-      'for (i--; i < count; i++) {}',
-      featureSet: spread,
-    );
-    assertNoErrors();
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    ForPartsWithExpression forLoopParts = forStatement.forLoopParts;
-    expect(forLoopParts.initialization, isNotNull);
-    expect(forLoopParts.leftSeparator, isNotNull);
-    expect(forLoopParts.condition, isNotNull);
-    expect(forLoopParts.rightSeparator, isNotNull);
-    expect(forLoopParts.updaters, hasLength(1));
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_loop_i2() {
-    ForStatement forStatement = parseStatement(
-      'for (var i = 0;;) {}',
-      featureSet: spread,
-    );
-    assertNoErrors();
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    ForPartsWithDeclarations forLoopParts = forStatement.forLoopParts;
-    VariableDeclarationList variables = forLoopParts.variables;
-    expect(variables, isNotNull);
-    expect(variables.metadata, hasLength(0));
-    expect(variables.variables, hasLength(1));
-    expect(forLoopParts.leftSeparator, isNotNull);
-    expect(forLoopParts.condition, isNull);
-    expect(forLoopParts.rightSeparator, isNotNull);
-    expect(forLoopParts.updaters, hasLength(0));
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_loop_i_withMetadata2() {
-    ForStatement forStatement = parseStatement(
-      'for (@A var i = 0;;) {}',
-      featureSet: spread,
-    );
-    assertNoErrors();
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    ForPartsWithDeclarations forLoopParts = forStatement.forLoopParts;
-    VariableDeclarationList variables = forLoopParts.variables;
-    expect(variables, isNotNull);
-    expect(variables.metadata, hasLength(1));
-    expect(variables.variables, hasLength(1));
-    expect(forLoopParts.leftSeparator, isNotNull);
-    expect(forLoopParts.condition, isNull);
-    expect(forLoopParts.rightSeparator, isNotNull);
-    expect(forLoopParts.updaters, hasLength(0));
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_loop_ic2() {
-    ForStatement forStatement = parseStatement(
-      'for (var i = 0; i < count;) {}',
-      featureSet: spread,
-    );
-    assertNoErrors();
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    ForPartsWithDeclarations forLoopParts = forStatement.forLoopParts;
-    VariableDeclarationList variables = forLoopParts.variables;
-    expect(variables, isNotNull);
-    expect(variables.variables, hasLength(1));
-    expect(forLoopParts.leftSeparator, isNotNull);
-    expect(forLoopParts.condition, isNotNull);
-    expect(forLoopParts.rightSeparator, isNotNull);
-    expect(forLoopParts.updaters, hasLength(0));
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_loop_icu2() {
-    ForStatement forStatement = parseStatement(
-      'for (var i = 0; i < count; i++) {}',
-      featureSet: spread,
-    );
-    assertNoErrors();
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    ForPartsWithDeclarations forLoopParts = forStatement.forLoopParts;
-    VariableDeclarationList variables = forLoopParts.variables;
-    expect(variables, isNotNull);
-    expect(variables.variables, hasLength(1));
-    expect(forLoopParts.leftSeparator, isNotNull);
-    expect(forLoopParts.condition, isNotNull);
-    expect(forLoopParts.rightSeparator, isNotNull);
-    expect(forLoopParts.updaters, hasLength(1));
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_loop_iicuu2() {
-    ForStatement forStatement = parseStatement(
-      'for (int i = 0, j = count; i < j; i++, j--) {}',
-      featureSet: spread,
-    );
-    assertNoErrors();
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    ForPartsWithDeclarations forLoopParts = forStatement.forLoopParts;
-    VariableDeclarationList variables = forLoopParts.variables;
-    expect(variables, isNotNull);
-    expect(variables.variables, hasLength(2));
-    expect(forLoopParts.leftSeparator, isNotNull);
-    expect(forLoopParts.condition, isNotNull);
-    expect(forLoopParts.rightSeparator, isNotNull);
-    expect(forLoopParts.updaters, hasLength(2));
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_loop_iu2() {
-    ForStatement forStatement = parseStatement(
-      'for (var i = 0;; i++) {}',
-      featureSet: spread,
-    );
-    assertNoErrors();
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    ForPartsWithDeclarations forLoopParts = forStatement.forLoopParts;
-    VariableDeclarationList variables = forLoopParts.variables;
-    expect(variables, isNotNull);
-    expect(variables.variables, hasLength(1));
-    expect(forLoopParts.leftSeparator, isNotNull);
-    expect(forLoopParts.condition, isNull);
-    expect(forLoopParts.rightSeparator, isNotNull);
-    expect(forLoopParts.updaters, hasLength(1));
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_loop_u2() {
-    ForStatement forStatement = parseStatement(
-      'for (;; i++) {}',
-      featureSet: spread,
-    );
-    assertNoErrors();
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    ForPartsWithExpression forLoopParts = forStatement.forLoopParts;
-    expect(forLoopParts.initialization, isNull);
-    expect(forLoopParts.leftSeparator, isNotNull);
-    expect(forLoopParts.condition, isNull);
-    expect(forLoopParts.rightSeparator, isNotNull);
-    expect(forLoopParts.updaters, hasLength(1));
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseLocalVariable_external() {
-    parseStatement('external int i;', featureSet: nonNullable);
-    assertErrors(errors: [
-      expectedError(ParserErrorCode.EXTRANEOUS_MODIFIER, 0, 8),
-    ]);
-  }
-
-  void test_partial_typeArg1_34850() {
-    var unit = parseCompilationUnit('<bar<', errors: [
-      expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 0, 1),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 5, 0),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 1, 3),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 5, 0),
-    ]);
-    // Validate that recovery has properly updated the token stream.
-    analyzer.Token token = unit.beginToken;
-    while (!token.isEof) {
-      expect(token.type, isNot(TokenType.GT_GT));
-      analyzer.Token next = token.next;
-      expect(next.previous, token);
-      token = next;
-    }
-  }
-
-  void test_partial_typeArg2_34850() {
-    var unit = parseCompilationUnit('foo <bar<', errors: [
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 5, 3),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 0, 3),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 9, 0),
-    ]);
-    // Validate that recovery has properly updated the token stream.
-    analyzer.Token token = unit.beginToken;
-    while (!token.isEof) {
-      expect(token.type, isNot(TokenType.GT_GT));
-      analyzer.Token next = token.next;
-      expect(next.previous, token);
-      token = next;
-    }
-  }
-}
-
-/// Tests of the fasta parser based on [TopLevelParserTestMixin].
-@reflectiveTest
-class TopLevelParserTest_Fasta extends FastaParserTestCase
-    with TopLevelParserTestMixin {
-  void test_parseClassDeclaration_native_allowed() {
-    allowNativeClause = true;
-    test_parseClassDeclaration_native();
-  }
-
-  void test_parseClassDeclaration_native_allowedWithFields() {
-    allowNativeClause = true;
-    createParser(r'''
-class A native 'something' {
-  final int x;
-  A() {}
-}
-''');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-  }
-
-  void test_parseClassDeclaration_native_missing_literal() {
-    createParser('class A native {}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    if (allowNativeClause) {
-      assertNoErrors();
-    } else {
-      assertErrorsWithCodes([
-        ParserErrorCode.NATIVE_CLAUSE_SHOULD_BE_ANNOTATION,
-      ]);
-    }
-    expect(member, TypeMatcher<ClassDeclaration>());
-    ClassDeclaration declaration = member;
-    expect(declaration.nativeClause, isNotNull);
-    expect(declaration.nativeClause.nativeKeyword, isNotNull);
-    expect(declaration.nativeClause.name, isNull);
-    expect(declaration.endToken.type, TokenType.CLOSE_CURLY_BRACKET);
-  }
-
-  void test_parseClassDeclaration_native_missing_literal_allowed() {
-    allowNativeClause = true;
-    test_parseClassDeclaration_native_missing_literal();
-  }
-
-  void test_parseClassDeclaration_native_missing_literal_not_allowed() {
-    allowNativeClause = false;
-    test_parseClassDeclaration_native_missing_literal();
-  }
-
-  void test_parseClassDeclaration_native_not_allowed() {
-    allowNativeClause = false;
-    test_parseClassDeclaration_native();
-  }
-
-  void test_parseMixinDeclaration_empty() {
-    createParser('mixin A {}');
-    MixinDeclaration declaration = parseFullCompilationUnitMember();
-    expect(declaration, isNotNull);
-    assertNoErrors();
-    expect(declaration.metadata, isEmpty);
-    expect(declaration.documentationComment, isNull);
-    expect(declaration.onClause, isNull);
-    expect(declaration.implementsClause, isNull);
-    expect(declaration.mixinKeyword, isNotNull);
-    expect(declaration.leftBracket, isNotNull);
-    expect(declaration.name.name, 'A');
-    expect(declaration.members, hasLength(0));
-    expect(declaration.rightBracket, isNotNull);
-    expect(declaration.typeParameters, isNull);
-  }
-
-  void test_parseMixinDeclaration_implements() {
-    createParser('mixin A implements B {}');
-    MixinDeclaration declaration = parseFullCompilationUnitMember();
-    expect(declaration, isNotNull);
-    assertNoErrors();
-    expect(declaration.metadata, isEmpty);
-    expect(declaration.documentationComment, isNull);
-    expect(declaration.onClause, isNull);
-    ImplementsClause implementsClause = declaration.implementsClause;
-    expect(implementsClause.implementsKeyword, isNotNull);
-    NodeList<TypeName> interfaces = implementsClause.interfaces;
-    expect(interfaces, hasLength(1));
-    expect(interfaces[0].name.name, 'B');
-    expect(interfaces[0].typeArguments, isNull);
-    expect(declaration.mixinKeyword, isNotNull);
-    expect(declaration.leftBracket, isNotNull);
-    expect(declaration.name.name, 'A');
-    expect(declaration.members, hasLength(0));
-    expect(declaration.rightBracket, isNotNull);
-    expect(declaration.typeParameters, isNull);
-  }
-
-  void test_parseMixinDeclaration_implements2() {
-    createParser('mixin A implements B<T>, C {}');
-    MixinDeclaration declaration = parseFullCompilationUnitMember();
-    expect(declaration, isNotNull);
-    assertNoErrors();
-    expect(declaration.metadata, isEmpty);
-    expect(declaration.documentationComment, isNull);
-    expect(declaration.onClause, isNull);
-    ImplementsClause implementsClause = declaration.implementsClause;
-    expect(implementsClause.implementsKeyword, isNotNull);
-    NodeList<TypeName> interfaces = implementsClause.interfaces;
-    expect(interfaces, hasLength(2));
-    expect(interfaces[0].name.name, 'B');
-    expect(interfaces[0].typeArguments.arguments, hasLength(1));
-    expect(interfaces[1].name.name, 'C');
-    expect(interfaces[1].typeArguments, isNull);
-    expect(declaration.mixinKeyword, isNotNull);
-    expect(declaration.leftBracket, isNotNull);
-    expect(declaration.name.name, 'A');
-    expect(declaration.members, hasLength(0));
-    expect(declaration.rightBracket, isNotNull);
-    expect(declaration.typeParameters, isNull);
-  }
-
-  void test_parseMixinDeclaration_metadata() {
-    createParser('@Z mixin A {}');
-    MixinDeclaration declaration = parseFullCompilationUnitMember();
-    expect(declaration, isNotNull);
-    assertNoErrors();
-    NodeList<Annotation> metadata = declaration.metadata;
-    expect(metadata, hasLength(1));
-    expect(metadata[0].name.name, 'Z');
-    expect(declaration.documentationComment, isNull);
-    expect(declaration.onClause, isNull);
-    expect(declaration.implementsClause, isNull);
-    expect(declaration.mixinKeyword, isNotNull);
-    expect(declaration.leftBracket, isNotNull);
-    expect(declaration.name.name, 'A');
-    expect(declaration.members, hasLength(0));
-    expect(declaration.rightBracket, isNotNull);
-    expect(declaration.typeParameters, isNull);
-  }
-
-  void test_parseMixinDeclaration_on() {
-    createParser('mixin A on B {}');
-    MixinDeclaration declaration = parseFullCompilationUnitMember();
-    expect(declaration, isNotNull);
-    assertNoErrors();
-    expect(declaration.metadata, isEmpty);
-    expect(declaration.documentationComment, isNull);
-    OnClause onClause = declaration.onClause;
-    expect(onClause.onKeyword, isNotNull);
-    NodeList<TypeName> constraints = onClause.superclassConstraints;
-    expect(constraints, hasLength(1));
-    expect(constraints[0].name.name, 'B');
-    expect(constraints[0].typeArguments, isNull);
-    expect(declaration.implementsClause, isNull);
-    expect(declaration.mixinKeyword, isNotNull);
-    expect(declaration.leftBracket, isNotNull);
-    expect(declaration.name.name, 'A');
-    expect(declaration.members, hasLength(0));
-    expect(declaration.rightBracket, isNotNull);
-    expect(declaration.typeParameters, isNull);
-  }
-
-  void test_parseMixinDeclaration_on2() {
-    createParser('mixin A on B, C<T> {}');
-    MixinDeclaration declaration = parseFullCompilationUnitMember();
-    expect(declaration, isNotNull);
-    assertNoErrors();
-    expect(declaration.metadata, isEmpty);
-    expect(declaration.documentationComment, isNull);
-    OnClause onClause = declaration.onClause;
-    expect(onClause.onKeyword, isNotNull);
-    NodeList<TypeName> constraints = onClause.superclassConstraints;
-    expect(constraints, hasLength(2));
-    expect(constraints[0].name.name, 'B');
-    expect(constraints[0].typeArguments, isNull);
-    expect(constraints[1].name.name, 'C');
-    expect(constraints[1].typeArguments.arguments, hasLength(1));
-    expect(declaration.implementsClause, isNull);
-    expect(declaration.mixinKeyword, isNotNull);
-    expect(declaration.leftBracket, isNotNull);
-    expect(declaration.name.name, 'A');
-    expect(declaration.members, hasLength(0));
-    expect(declaration.rightBracket, isNotNull);
-    expect(declaration.typeParameters, isNull);
-  }
-
-  void test_parseMixinDeclaration_onAndImplements() {
-    createParser('mixin A on B implements C {}');
-    MixinDeclaration declaration = parseFullCompilationUnitMember();
-    expect(declaration, isNotNull);
-    assertNoErrors();
-    expect(declaration.metadata, isEmpty);
-    expect(declaration.documentationComment, isNull);
-    OnClause onClause = declaration.onClause;
-    expect(onClause.onKeyword, isNotNull);
-    NodeList<TypeName> constraints = onClause.superclassConstraints;
-    expect(constraints, hasLength(1));
-    expect(constraints[0].name.name, 'B');
-    expect(constraints[0].typeArguments, isNull);
-    ImplementsClause implementsClause = declaration.implementsClause;
-    expect(implementsClause.implementsKeyword, isNotNull);
-    NodeList<TypeName> interfaces = implementsClause.interfaces;
-    expect(interfaces, hasLength(1));
-    expect(interfaces[0].name.name, 'C');
-    expect(interfaces[0].typeArguments, isNull);
-    expect(declaration.mixinKeyword, isNotNull);
-    expect(declaration.leftBracket, isNotNull);
-    expect(declaration.name.name, 'A');
-    expect(declaration.members, hasLength(0));
-    expect(declaration.rightBracket, isNotNull);
-    expect(declaration.typeParameters, isNull);
-  }
-
-  void test_parseMixinDeclaration_simple() {
-    createParser('''
-mixin A {
-  int f;
-  int get g => f;
-  set s(int v) {f = v;}
-  int add(int v) => f = f + v;
-}''');
-    MixinDeclaration declaration = parseFullCompilationUnitMember();
-    expect(declaration, isNotNull);
-    assertNoErrors();
-    expect(declaration.metadata, isEmpty);
-    expect(declaration.documentationComment, isNull);
-    expect(declaration.onClause, isNull);
-    expect(declaration.implementsClause, isNull);
-    expect(declaration.mixinKeyword, isNotNull);
-    expect(declaration.leftBracket, isNotNull);
-    expect(declaration.name.name, 'A');
-    expect(declaration.members, hasLength(4));
-    expect(declaration.rightBracket, isNotNull);
-    expect(declaration.typeParameters, isNull);
-  }
-
-  void test_parseMixinDeclaration_withDocumentationComment() {
-    createParser('/// Doc\nmixin M {}');
-    MixinDeclaration declaration = parseFullCompilationUnitMember();
-    expectCommentText(declaration.documentationComment, '/// Doc');
-  }
-
-  void test_parseTopLevelVariable_external() {
-    var unit = parseCompilationUnit('external int i;', featureSet: nonNullable);
-    var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
-    expect(declaration.externalKeyword, isNotNull);
-  }
-
-  void test_parseTopLevelVariable_external_late() {
-    var unit = parseCompilationUnit('external late int? i;',
-        featureSet: nonNullable,
-        errors: [
-          expectedError(ParserErrorCode.EXTERNAL_LATE_FIELD, 0, 8),
-        ]);
-    var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
-    expect(declaration.externalKeyword, isNotNull);
-  }
-
-  void test_parseTopLevelVariable_external_late_final() {
-    var unit = parseCompilationUnit('external late final int? i;',
-        featureSet: nonNullable,
-        errors: [
-          expectedError(ParserErrorCode.EXTERNAL_LATE_FIELD, 0, 8),
-        ]);
-    var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
-    expect(declaration.externalKeyword, isNotNull);
-  }
-
-  void test_parseTopLevelVariable_final_late() {
-    var unit = parseCompilationUnit('final late a;',
-        featureSet: nonNullable,
-        errors: [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 6, 4)]);
-    var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
-    var declarationList = declaration.variables;
-    expect(declarationList.keyword.lexeme, 'final');
-    expect(declarationList.type, isNull);
-    expect(declarationList.variables, hasLength(1));
-  }
-
-  void test_parseTopLevelVariable_late() {
-    var unit = parseCompilationUnit('late a;',
-        featureSet: nonNullable,
-        errors: [
-          expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 5, 1)
-        ]);
-    var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
-    var declarationList = declaration.variables;
-    expect(declarationList.keyword, isNull);
-    expect(declarationList.type, isNull);
-    expect(declarationList.variables, hasLength(1));
-  }
-
-  void test_parseTopLevelVariable_late_final() {
-    var unit = parseCompilationUnit('late final a;', featureSet: nonNullable);
-    var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
-    var declarationList = declaration.variables;
-    expect(declarationList.keyword.lexeme, 'final');
-    expect(declarationList.type, isNull);
-    expect(declarationList.variables, hasLength(1));
-  }
-
-  void test_parseTopLevelVariable_late_init() {
-    var unit = parseCompilationUnit('late a = 0;',
-        featureSet: nonNullable,
-        errors: [
-          expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 5, 1)
-        ]);
-    var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
-    var declarationList = declaration.variables;
-    expect(declarationList.keyword, isNull);
-    expect(declarationList.type, isNull);
-    expect(declarationList.variables, hasLength(1));
-  }
-
-  void test_parseTopLevelVariable_late_type() {
-    var unit = parseCompilationUnit('late A a;', featureSet: nonNullable);
-    var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
-    var declarationList = declaration.variables;
-    expect(declarationList.lateKeyword, isNotNull);
-    expect(declarationList.keyword, isNull);
-    expect(declarationList.type, isNotNull);
-    expect(declarationList.variables, hasLength(1));
-  }
-
-  void test_parseTopLevelVariable_non_external() {
-    var unit = parseCompilationUnit('int i;', featureSet: nonNullable);
-    var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
-    expect(declaration.externalKeyword, isNull);
-  }
-}
-
-@reflectiveTest
-class VarianceParserTest_Fasta extends FastaParserTestCase {
-  @override
-  CompilationUnit parseCompilationUnit(String content,
-      {List<ErrorCode> codes,
-      List<ExpectedError> errors,
-      FeatureSet featureSet}) {
-    return super.parseCompilationUnit(content,
-        codes: codes,
-        errors: errors,
-        featureSet: featureSet ??
-            FeatureSet.forTesting(
-              sdkVersion: '2.5.0',
-              additionalFeatures: [Feature.variance],
-            ));
-  }
-
-  void test_class_disabled_multiple() {
-    parseCompilationUnit('class A<in T, inout U, out V> { }',
-        errors: [
-          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 8, 2),
-          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 14, 5),
-          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 23, 3)
-        ],
-        featureSet: FeatureSet.forTesting(sdkVersion: '2.5.0'));
-  }
-
-  void test_class_disabled_single() {
-    parseCompilationUnit('class A<out T> { }',
-        errors: [
-          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 8, 3),
-        ],
-        featureSet: FeatureSet.forTesting(sdkVersion: '2.5.0'));
-  }
-
-  void test_class_enabled_multiple() {
-    var unit = parseCompilationUnit('class A<in T, inout U, out V, W> { }');
-    expect(unit.declarations, hasLength(1));
-    var classDecl = unit.declarations[0] as ClassDeclaration;
-    expect(classDecl.name.name, 'A');
-
-    expect(classDecl.typeParameters.typeParameters, hasLength(4));
-    expect(classDecl.typeParameters.typeParameters[0].name.name, 'T');
-    expect(classDecl.typeParameters.typeParameters[1].name.name, 'U');
-    expect(classDecl.typeParameters.typeParameters[2].name.name, 'V');
-    expect(classDecl.typeParameters.typeParameters[3].name.name, 'W');
-
-    var typeParameterImplList = classDecl.typeParameters.typeParameters;
-    expect((typeParameterImplList[0] as TypeParameterImpl).varianceKeyword,
-        isNotNull);
-    expect(
-        (typeParameterImplList[0] as TypeParameterImpl).varianceKeyword.lexeme,
-        "in");
-    expect((typeParameterImplList[1] as TypeParameterImpl).varianceKeyword,
-        isNotNull);
-    expect(
-        (typeParameterImplList[1] as TypeParameterImpl).varianceKeyword.lexeme,
-        "inout");
-    expect((typeParameterImplList[2] as TypeParameterImpl).varianceKeyword,
-        isNotNull);
-    expect(
-        (typeParameterImplList[2] as TypeParameterImpl).varianceKeyword.lexeme,
-        "out");
-    expect((typeParameterImplList[3] as TypeParameterImpl).varianceKeyword,
-        isNull);
-  }
-
-  void test_class_enabled_multipleVariances() {
-    var unit = parseCompilationUnit('class A<in out inout T> { }', errors: [
-      expectedError(ParserErrorCode.MULTIPLE_VARIANCE_MODIFIERS, 11, 3),
-      expectedError(ParserErrorCode.MULTIPLE_VARIANCE_MODIFIERS, 15, 5)
-    ]);
-    expect(unit.declarations, hasLength(1));
-    var classDecl = unit.declarations[0] as ClassDeclaration;
-    expect(classDecl.name.name, 'A');
-    expect(classDecl.typeParameters.typeParameters, hasLength(1));
-    expect(classDecl.typeParameters.typeParameters[0].name.name, 'T');
-  }
-
-  void test_class_enabled_single() {
-    var unit = parseCompilationUnit('class A<in T> { }');
-    expect(unit.declarations, hasLength(1));
-    var classDecl = unit.declarations[0] as ClassDeclaration;
-    expect(classDecl.name.name, 'A');
-    expect(classDecl.typeParameters.typeParameters, hasLength(1));
-    expect(classDecl.typeParameters.typeParameters[0].name.name, 'T');
-
-    var typeParameterImpl =
-        classDecl.typeParameters.typeParameters[0] as TypeParameterImpl;
-    expect(typeParameterImpl.varianceKeyword, isNotNull);
-    expect(typeParameterImpl.varianceKeyword.lexeme, "in");
-  }
-
-  void test_function_disabled() {
-    parseCompilationUnit('void A(in int value) {}',
-        errors: [
-          expectedError(
-              ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD, 7, 2),
-          expectedError(ParserErrorCode.EXPECTED_TOKEN, 10, 3),
-        ],
-        featureSet: FeatureSet.forTesting(sdkVersion: '2.5.0'));
-  }
-
-  void test_function_enabled() {
-    parseCompilationUnit('void A(in int value) {}', errors: [
-      expectedError(ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD, 7, 2),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 10, 3),
-    ]);
-  }
-
-  void test_list_disabled() {
-    parseCompilationUnit('List<out String> stringList = [];',
-        errors: [
-          expectedError(ParserErrorCode.EXPECTED_TOKEN, 9, 6),
-        ],
-        featureSet: FeatureSet.forTesting(sdkVersion: '2.5.0'));
-  }
-
-  void test_list_enabled() {
-    parseCompilationUnit('List<out String> stringList = [];', errors: [
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 9, 6),
-    ]);
-  }
-
-  void test_mixin_disabled_multiple() {
-    parseCompilationUnit('mixin A<inout T, out U> { }',
-        errors: [
-          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 8, 5),
-          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 17, 3),
-        ],
-        featureSet: FeatureSet.forTesting(sdkVersion: '2.5.0'));
-  }
-
-  void test_mixin_disabled_single() {
-    parseCompilationUnit('mixin A<inout T> { }',
-        errors: [
-          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 8, 5),
-        ],
-        featureSet: FeatureSet.forTesting(sdkVersion: '2.5.0'));
-  }
-
-  void test_mixin_enabled_single() {
-    var unit = parseCompilationUnit('mixin A<inout T> { }');
-    expect(unit.declarations, hasLength(1));
-    var mixinDecl = unit.declarations[0] as MixinDeclaration;
-    expect(mixinDecl.name.name, 'A');
-    expect(mixinDecl.typeParameters.typeParameters, hasLength(1));
-    expect(mixinDecl.typeParameters.typeParameters[0].name.name, 'T');
-  }
-
-  void test_typedef_disabled() {
-    parseCompilationUnit('typedef A<inout X> = X Function(X);',
-        errors: [
-          expectedError(ParserErrorCode.EXPECTED_TOKEN, 16, 1),
-        ],
-        featureSet: FeatureSet.forTesting(sdkVersion: '2.5.0'));
-  }
-
-  void test_typedef_enabled() {
-    parseCompilationUnit('typedef A<inout X> = X Function(X);', errors: [
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 16, 1),
-    ]);
-  }
-}
diff --git a/pkg/analyzer/test/generated/parser_test.dart b/pkg/analyzer/test/generated/parser_test.dart
deleted file mode 100644
index e5f8cb0..0000000
--- a/pkg/analyzer/test/generated/parser_test.dart
+++ /dev/null
@@ -1,16617 +0,0 @@
-// 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.
-
-import 'package:_fe_analyzer_shared/src/scanner/abstract_scanner.dart'
-    show AbstractScanner;
-import 'package:_fe_analyzer_shared/src/scanner/errors.dart';
-import 'package:_fe_analyzer_shared/src/scanner/scanner.dart' as fasta;
-import 'package:analyzer/dart/analysis/features.dart';
-import 'package:analyzer/dart/ast/ast.dart';
-import 'package:analyzer/dart/ast/token.dart';
-import 'package:analyzer/error/error.dart';
-import 'package:analyzer/src/dart/ast/ast.dart'
-    show CompilationUnitImpl, InstanceCreationExpressionImpl;
-import 'package:analyzer/src/dart/ast/token.dart';
-import 'package:analyzer/src/dart/scanner/scanner.dart';
-import 'package:analyzer/src/error/codes.dart';
-import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
-import 'package:analyzer/src/generated/testing/token_factory.dart';
-import 'package:analyzer/src/generated/utilities_dart.dart';
-import 'package:pub_semver/src/version.dart';
-import 'package:test/test.dart';
-import 'package:test_reflective_loader/test_reflective_loader.dart';
-
-import '../util/ast_type_matchers.dart';
-import 'parser_test_base.dart';
-import 'test_support.dart';
-
-main() {
-  defineReflectiveSuite(() {
-    // TODO(srawlins): Migrate individual tests into their own files; this file
-    // is more than 16k lines and the formatter and sorter almost choke on it.
-    defineReflectiveTests(ClassMemberParserTest);
-    defineReflectiveTests(ComplexParserTest);
-    defineReflectiveTests(ErrorParserTest);
-    defineReflectiveTests(ExpressionParserTest);
-    defineReflectiveTests(ExtensionMethodsParserTest);
-    defineReflectiveTests(FormalParameterParserTest);
-    defineReflectiveTests(NonErrorParserTest);
-  });
-}
-
-/// Tests which exercise the parser using a class member.
-@reflectiveTest
-class ClassMemberParserTest extends FastaParserTestCase
-    implements AbstractParserViaProxyTestCase {
-  final tripleShift = FeatureSet.forTesting(
-      sdkVersion: '2.0.0', additionalFeatures: [Feature.triple_shift]);
-
-  void test_parse_member_called_late() {
-    var unit = parseCompilationUnit(
-        'class C { void late() { new C().late(); } }',
-        featureSet: nonNullable);
-    var declaration = unit.declarations[0] as ClassDeclaration;
-    var method = declaration.members[0] as MethodDeclaration;
-
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name.name, 'late');
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-
-    var body = method.body as BlockFunctionBody;
-    var statement = body.block.statements[0] as ExpressionStatement;
-    var invocation = statement.expression as MethodInvocation;
-    expect(invocation.operator.lexeme, '.');
-    expect(invocation.toSource(), 'new C().late()');
-  }
-
-  void test_parseAwaitExpression_asStatement_inAsync() {
-    createParser('m() async { await x; }');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    FunctionBody body = method.body;
-    expect(body, isBlockFunctionBody);
-    Statement statement = (body as BlockFunctionBody).block.statements[0];
-    expect(statement, isExpressionStatement);
-    Expression expression = (statement as ExpressionStatement).expression;
-    expect(expression, isAwaitExpression);
-    expect((expression as AwaitExpression).awaitKeyword, isNotNull);
-    expect((expression as AwaitExpression).expression, isNotNull);
-  }
-
-  void test_parseAwaitExpression_asStatement_inSync() {
-    createParser('m() { await x; }');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    FunctionBody body = method.body;
-    expect(body, isBlockFunctionBody);
-    Statement statement = (body as BlockFunctionBody).block.statements[0];
-    expect(statement, isVariableDeclarationStatement);
-  }
-
-  void test_parseAwaitExpression_inSync() {
-    createParser('m() { return await x + await y; }');
-    MethodDeclaration method = parser.parseClassMember('C');
-    expect(method, isNotNull);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 13, 5),
-      expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 23, 5)
-    ]);
-    FunctionBody body = method.body;
-    expect(body, isBlockFunctionBody);
-    Statement statement = (body as BlockFunctionBody).block.statements[0];
-    expect(statement, isReturnStatement);
-    Expression expression = (statement as ReturnStatement).expression;
-    expect(expression, isBinaryExpression);
-  }
-
-  void test_parseClassMember_constructor_withDocComment() {
-    createParser('/// Doc\nC();');
-    var constructor = parser.parseClassMember('C') as ConstructorDeclaration;
-    expectCommentText(constructor.documentationComment, '/// Doc');
-  }
-
-  void test_parseClassMember_constructor_withInitializers() {
-    // TODO(brianwilkerson) Test other kinds of class members: fields, getters
-    // and setters.
-    createParser('C(_, _\$, this.__) : _a = _ + _\$ {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isConstructorDeclaration);
-    ConstructorDeclaration constructor = member;
-    expect(constructor.body, isNotNull);
-    expect(constructor.separator, isNotNull);
-    expect(constructor.externalKeyword, isNull);
-    expect(constructor.constKeyword, isNull);
-    expect(constructor.factoryKeyword, isNull);
-    expect(constructor.name, isNull);
-    expect(constructor.parameters, isNotNull);
-    expect(constructor.period, isNull);
-    expect(constructor.returnType, isNotNull);
-    expect(constructor.initializers, hasLength(1));
-  }
-
-  void test_parseClassMember_field_covariant() {
-    createParser('covariant T f;');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFieldDeclaration);
-    FieldDeclaration field = member;
-    expect(field.covariantKeyword, isNotNull);
-    expect(field.documentationComment, isNull);
-    expect(field.metadata, hasLength(0));
-    expect(field.staticKeyword, isNull);
-    VariableDeclarationList list = field.fields;
-    expect(list, isNotNull);
-    expect(list.keyword, isNull);
-    expect(list.isConst, isFalse);
-    expect(list.isFinal, isFalse);
-    expect(list.isLate, isFalse);
-    expect(list.lateKeyword, isNull);
-    NodeList<VariableDeclaration> variables = list.variables;
-    expect(variables, hasLength(1));
-    VariableDeclaration variable = variables[0];
-    expect(variable.name, isNotNull);
-  }
-
-  void test_parseClassMember_field_generic() {
-    createParser('List<List<N>> _allComponents = new List<List<N>>();');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFieldDeclaration);
-    FieldDeclaration field = member;
-    expect(field.covariantKeyword, isNull);
-    expect(field.documentationComment, isNull);
-    expect(field.metadata, hasLength(0));
-    expect(field.staticKeyword, isNull);
-    VariableDeclarationList list = field.fields;
-    expect(list, isNotNull);
-    expect(list, isNotNull);
-    expect(list.keyword, isNull);
-    expect(list.isConst, isFalse);
-    expect(list.isFinal, isFalse);
-    expect(list.isLate, isFalse);
-    expect(list.lateKeyword, isNull);
-    TypeName type = list.type;
-    expect(type.name.name, 'List');
-    NodeList typeArguments = type.typeArguments.arguments;
-    expect(typeArguments, hasLength(1));
-    TypeName type2 = typeArguments[0];
-    expect(type2.name.name, 'List');
-    NodeList typeArguments2 = type2.typeArguments.arguments;
-    expect(typeArguments2, hasLength(1));
-    TypeName type3 = typeArguments2[0];
-    expect(type3.name.name, 'N');
-    NodeList<VariableDeclaration> variables = list.variables;
-    expect(variables, hasLength(1));
-    VariableDeclaration variable = variables[0];
-    expect(variable.name, isNotNull);
-  }
-
-  void test_parseClassMember_field_gftType_gftReturnType() {
-    createParser('''
-Function(int) Function(String) v;
-''');
-    ClassMember member = parser.parseClassMember('C');
-    assertNoErrors();
-    expect(member, isFieldDeclaration);
-    VariableDeclarationList fields = (member as FieldDeclaration).fields;
-    expect(fields.type, isGenericFunctionType);
-  }
-
-  void test_parseClassMember_field_gftType_noReturnType() {
-    createParser('''
-Function(int, String) v;
-''');
-    ClassMember member = parser.parseClassMember('C');
-    assertNoErrors();
-    expect(member, isFieldDeclaration);
-    VariableDeclarationList fields = (member as FieldDeclaration).fields;
-    expect(fields.type, isGenericFunctionType);
-  }
-
-  void test_parseClassMember_field_instance_prefixedType() {
-    createParser('p.A f;');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFieldDeclaration);
-    FieldDeclaration field = member;
-    expect(field.covariantKeyword, isNull);
-    expect(field.documentationComment, isNull);
-    expect(field.metadata, hasLength(0));
-    expect(field.staticKeyword, isNull);
-    VariableDeclarationList list = field.fields;
-    expect(list, isNotNull);
-    expect(list, isNotNull);
-    expect(list.keyword, isNull);
-    expect(list.isConst, isFalse);
-    expect(list.isFinal, isFalse);
-    expect(list.isLate, isFalse);
-    expect(list.lateKeyword, isNull);
-    NodeList<VariableDeclaration> variables = list.variables;
-    expect(variables, hasLength(1));
-    VariableDeclaration variable = variables[0];
-    expect(variable.name, isNotNull);
-    _assertIsDeclarationName(variable.name);
-  }
-
-  void test_parseClassMember_field_namedGet() {
-    createParser('var get;');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFieldDeclaration);
-    FieldDeclaration field = member;
-    expect(field.covariantKeyword, isNull);
-    expect(field.documentationComment, isNull);
-    expect(field.metadata, hasLength(0));
-    expect(field.staticKeyword, isNull);
-    VariableDeclarationList list = field.fields;
-    expect(list, isNotNull);
-    expect(list, isNotNull);
-    expect(list.keyword, isNotNull);
-    expect(list.isConst, isFalse);
-    expect(list.isFinal, isFalse);
-    expect(list.isLate, isFalse);
-    expect(list.lateKeyword, isNull);
-    NodeList<VariableDeclaration> variables = list.variables;
-    expect(variables, hasLength(1));
-    VariableDeclaration variable = variables[0];
-    expect(variable.name, isNotNull);
-  }
-
-  void test_parseClassMember_field_namedOperator() {
-    createParser('var operator;');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFieldDeclaration);
-    FieldDeclaration field = member;
-    expect(field.covariantKeyword, isNull);
-    expect(field.documentationComment, isNull);
-    expect(field.metadata, hasLength(0));
-    expect(field.staticKeyword, isNull);
-    VariableDeclarationList list = field.fields;
-    expect(list, isNotNull);
-    expect(list, isNotNull);
-    expect(list.keyword, isNotNull);
-    expect(list.isConst, isFalse);
-    expect(list.isFinal, isFalse);
-    expect(list.isLate, isFalse);
-    expect(list.lateKeyword, isNull);
-    NodeList<VariableDeclaration> variables = list.variables;
-    expect(variables, hasLength(1));
-    VariableDeclaration variable = variables[0];
-    expect(variable.name, isNotNull);
-  }
-
-  void test_parseClassMember_field_namedOperator_withAssignment() {
-    createParser('var operator = (5);');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFieldDeclaration);
-    FieldDeclaration field = member;
-    expect(field.covariantKeyword, isNull);
-    expect(field.documentationComment, isNull);
-    expect(field.metadata, hasLength(0));
-    expect(field.staticKeyword, isNull);
-    VariableDeclarationList list = field.fields;
-    expect(list, isNotNull);
-    expect(list, isNotNull);
-    expect(list.keyword, isNotNull);
-    expect(list.isConst, isFalse);
-    expect(list.isFinal, isFalse);
-    expect(list.isLate, isFalse);
-    expect(list.lateKeyword, isNull);
-    NodeList<VariableDeclaration> variables = list.variables;
-    expect(variables, hasLength(1));
-    VariableDeclaration variable = variables[0];
-    expect(variable.name, isNotNull);
-    expect(variable.initializer, isNotNull);
-  }
-
-  void test_parseClassMember_field_namedSet() {
-    createParser('var set;');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFieldDeclaration);
-    FieldDeclaration field = member;
-    expect(field.covariantKeyword, isNull);
-    expect(field.documentationComment, isNull);
-    expect(field.metadata, hasLength(0));
-    expect(field.staticKeyword, isNull);
-    VariableDeclarationList list = field.fields;
-    expect(list, isNotNull);
-    expect(list, isNotNull);
-    expect(list.keyword, isNotNull);
-    expect(list.isConst, isFalse);
-    expect(list.isFinal, isFalse);
-    expect(list.isLate, isFalse);
-    expect(list.lateKeyword, isNull);
-    NodeList<VariableDeclaration> variables = list.variables;
-    expect(variables, hasLength(1));
-    VariableDeclaration variable = variables[0];
-    expect(variable.name, isNotNull);
-  }
-
-  void test_parseClassMember_field_nameKeyword() {
-    createParser('var for;');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD, 4, 3)
-    ]);
-  }
-
-  void test_parseClassMember_field_nameMissing() {
-    createParser('var ;');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 4, 1)]);
-  }
-
-  void test_parseClassMember_field_nameMissing2() {
-    createParser('var "";');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 4, 2)]);
-  }
-
-  void test_parseClassMember_field_static() {
-    createParser('static A f;');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFieldDeclaration);
-    FieldDeclaration field = member;
-    expect(field.covariantKeyword, isNull);
-    expect(field.documentationComment, isNull);
-    expect(field.metadata, hasLength(0));
-    expect(field.staticKeyword, isNotNull);
-    VariableDeclarationList list = field.fields;
-    expect(list, isNotNull);
-    expect(list, isNotNull);
-    expect(list.keyword, isNull);
-    expect(list.isConst, isFalse);
-    expect(list.isFinal, isFalse);
-    expect(list.isLate, isFalse);
-    expect(list.lateKeyword, isNull);
-    NodeList<VariableDeclaration> variables = list.variables;
-    expect(variables, hasLength(1));
-    VariableDeclaration variable = variables[0];
-    expect(variable.name, isNotNull);
-  }
-
-  void test_parseClassMember_finalAndCovariantLateWithInitializer() {
-    createParser(
-      'covariant late final int f = 0;',
-      featureSet: nonNullable,
-    );
-    parser.parseClassMember('C');
-    assertErrors(errors: [
-      expectedError(
-          ParserErrorCode.FINAL_AND_COVARIANT_LATE_WITH_INITIALIZER, 0, 9)
-    ]);
-  }
-
-  void test_parseClassMember_getter_functionType() {
-    createParser('int Function(int) get g {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    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_getter_void() {
-    createParser('void get g {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNotNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name, isNotNull);
-    _assertIsDeclarationName(method.name);
-    expect(method.operatorKeyword, isNull);
-    expect(method.body, isNotNull);
-    expect(method.parameters, isNull);
-  }
-
-  void test_parseClassMember_method_external() {
-    createParser('external m();');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNotNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.name, isNotNull);
-    _assertIsDeclarationName(method.name);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNull);
-
-    var body = method.body as EmptyFunctionBody;
-    expect(body.keyword, isNull);
-    expect(body.star, isNull);
-    expect(body.semicolon.type, TokenType.SEMICOLON);
-  }
-
-  void test_parseClassMember_method_external_withTypeAndArgs() {
-    createParser('external int m(int a);');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.body, isNotNull);
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNotNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-  }
-
-  void test_parseClassMember_method_generic_noReturnType() {
-    createParser('m<T>() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNotNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_generic_parameterType() {
-    createParser('m<T>(T p) => null;');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNotNull);
-
-    FormalParameterList parameters = method.parameters;
-    expect(parameters, isNotNull);
-    expect(parameters.parameters, hasLength(1));
-    var parameter = parameters.parameters[0] as SimpleFormalParameter;
-    var parameterType = parameter.type as TypeName;
-    expect(parameterType.name.name, 'T');
-
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_generic_returnType() {
-    createParser('T m<T>() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNotNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_generic_returnType_bound() {
-    createParser('T m<T extends num>() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect((method.returnType as TypeName).name.name, 'T');
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNotNull);
-    TypeParameter tp = method.typeParameters.typeParameters[0];
-    expect(tp.name.name, 'T');
-    expect(tp.extendsKeyword, isNotNull);
-    expect((tp.bound as TypeName).name.name, 'num');
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_generic_returnType_complex() {
-    createParser('Map<int, T> m<T>() => null;');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-
-    {
-      var returnType = method.returnType as TypeName;
-      expect(returnType, isNotNull);
-      expect(returnType.name.name, 'Map');
-
-      List<TypeAnnotation> typeArguments = returnType.typeArguments.arguments;
-      expect(typeArguments, hasLength(2));
-      expect((typeArguments[0] as TypeName).name.name, 'int');
-      expect((typeArguments[1] as TypeName).name.name, 'T');
-    }
-
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNotNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_generic_returnType_static() {
-    createParser('static T m<T>() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNotNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-    expect((method.returnType as TypeName).name.name, 'T');
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNotNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_generic_void() {
-    createParser('void m<T>() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNotNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_get_noType() {
-    createParser('get() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_get_static_namedAsClass() {
-    createParser('static int get C => 0;');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.MEMBER_WITH_CLASS_NAME, 15, 1),
-    ]);
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNotNull);
-    expect(method.propertyKeyword, isNotNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_get_type() {
-    createParser('int get() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_get_void() {
-    createParser('void get() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_gftReturnType_noReturnType() {
-    createParser('''
-Function<A>(core.List<core.int> x) m() => null;
-''');
-    ClassMember member = parser.parseClassMember('C');
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    expect((member as MethodDeclaration).body, isExpressionFunctionBody);
-  }
-
-  void test_parseClassMember_method_gftReturnType_voidReturnType() {
-    createParser('''
-void Function<A>(core.List<core.int> x) m() => null;
-''');
-    ClassMember member = parser.parseClassMember('C');
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    expect((member as MethodDeclaration).body, isExpressionFunctionBody);
-  }
-
-  void test_parseClassMember_method_native_allowed() {
-    allowNativeClause = true;
-    _parseClassMember_method_native();
-    assertNoErrors();
-  }
-
-  void test_parseClassMember_method_native_missing_literal_allowed() {
-    allowNativeClause = true;
-    _parseClassMember_method_native_missing_literal();
-    assertNoErrors();
-  }
-
-  void test_parseClassMember_method_native_missing_literal_not_allowed() {
-    allowNativeClause = false;
-    _parseClassMember_method_native_missing_literal();
-    listener.assertErrors([
-      expectedError(ParserErrorCode.NATIVE_CLAUSE_SHOULD_BE_ANNOTATION, 4, 6),
-    ]);
-  }
-
-  void test_parseClassMember_method_native_not_allowed() {
-    allowNativeClause = false;
-    _parseClassMember_method_native();
-    listener.assertErrors([
-      expectedError(ParserErrorCode.NATIVE_CLAUSE_SHOULD_BE_ANNOTATION, 4, 6),
-    ]);
-  }
-
-  void test_parseClassMember_method_native_with_body_allowed() {
-    allowNativeClause = true;
-    _parseClassMember_method_native_with_body();
-    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
-    assertErrorsWithCodes([
-      ParserErrorCode.EXTERNAL_METHOD_WITH_BODY,
-    ]);
-//      listener.assertErrors([
-//        expectedError(ParserErrorCode.EXTERNAL_METHOD_WITH_BODY, 17, 2),
-//      ]);
-  }
-
-  void test_parseClassMember_method_native_with_body_not_allowed() {
-    allowNativeClause = false;
-    _parseClassMember_method_native_with_body();
-    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
-    assertErrorsWithCodes([
-      ParserErrorCode.NATIVE_CLAUSE_SHOULD_BE_ANNOTATION,
-      ParserErrorCode.EXTERNAL_METHOD_WITH_BODY,
-    ]);
-//      listener.assertErrors([
-//        expectedError(ParserErrorCode.NATIVE_CLAUSE_SHOULD_BE_ANNOTATION, 4, 6),
-//        expectedError(ParserErrorCode.EXTERNAL_METHOD_WITH_BODY, 17, 2),
-//      ]);
-  }
-
-  void test_parseClassMember_method_operator_noType() {
-    createParser('operator() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_operator_type() {
-    createParser('int operator() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_operator_void() {
-    createParser('void operator() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_returnType_functionType() {
-    createParser('int Function(String) m() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name, isNotNull);
-    expect(method.name.name, 'm');
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_returnType_parameterized() {
-    createParser('p.A m() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_set_noType() {
-    createParser('set() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_set_static_namedAsClass() {
-    createParser('static void set C(_) {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.MEMBER_WITH_CLASS_NAME, 16, 1),
-    ]);
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNotNull);
-    expect(method.propertyKeyword, isNotNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_set_type() {
-    createParser('int set() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_set_void() {
-    createParser('void set() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_static_class() {
-    var unit = parseCompilationUnit('class C { static void m() {} }');
-
-    ClassDeclaration c = unit.declarations[0];
-    MethodDeclaration method = c.members[0];
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNotNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_static_mixin() {
-    var unit = parseCompilationUnit('mixin C { static void m() {} }');
-    MixinDeclaration c = unit.declarations[0];
-    MethodDeclaration method = c.members[0];
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNotNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_method_trailing_commas() {
-    createParser('void f(int x, int y,) {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_operator_functionType() {
-    createParser('int Function() operator +(int Function() f) {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isGenericFunctionType);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNotNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    NodeList<FormalParameter> parameters = method.parameters.parameters;
-    expect(parameters, hasLength(1));
-    expect(
-        (parameters[0] as SimpleFormalParameter).type, isGenericFunctionType);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_operator_gtgtgt() {
-    var unit = parseCompilationUnit(
-        'class C { bool operator >>>(other) => false; }',
-        featureSet: tripleShift);
-    var declaration = unit.declarations[0] as ClassDeclaration;
-    var method = declaration.members[0] as MethodDeclaration;
-
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name.name, '>>>');
-    expect(method.operatorKeyword, isNotNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_operator_gtgtgteq() {
-    var unit = parseCompilationUnit(
-        'class C { foo(int value) { x >>>= value; } }',
-        featureSet: tripleShift);
-    var declaration = unit.declarations[0] as ClassDeclaration;
-    var method = declaration.members[0] as MethodDeclaration;
-    var blockFunctionBody = method.body as BlockFunctionBody;
-    NodeList<Statement> statements = blockFunctionBody.block.statements;
-    expect(statements, hasLength(1));
-    var statement = statements[0] as ExpressionStatement;
-    var assignment = statement.expression as AssignmentExpression;
-    var leftHandSide = assignment.leftHandSide as SimpleIdentifier;
-    expect(leftHandSide.name, 'x');
-    expect(assignment.operator.lexeme, '>>>=');
-    var rightHandSide = assignment.rightHandSide as SimpleIdentifier;
-    expect(rightHandSide.name, 'value');
-  }
-
-  void test_parseClassMember_operator_index() {
-    createParser('int operator [](int i) {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNotNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_operator_indexAssign() {
-    createParser('int operator []=(int i) {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNotNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_operator_lessThan() {
-    createParser('bool operator <(other) => false;');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name.name, '<');
-    expect(method.operatorKeyword, isNotNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.body, isNotNull);
-  }
-
-  void test_parseClassMember_redirectingFactory_const() {
-    createParser('const factory C() = prefix.B.foo;');
-    var constructor = parser.parseClassMember('C') as ConstructorDeclaration;
-    assertNoErrors();
-    expect(constructor, isNotNull);
-    expect(constructor.externalKeyword, isNull);
-    expect(constructor.constKeyword.keyword, Keyword.CONST);
-    expect(constructor.factoryKeyword.keyword, Keyword.FACTORY);
-    expect(constructor.returnType.name, 'C');
-    expect(constructor.period, isNull);
-    expect(constructor.name, isNull);
-    _assertIsDeclarationName(constructor.returnType, false);
-    expect(constructor.parameters, isNotNull);
-    expect(constructor.parameters.parameters, isEmpty);
-    expect(constructor.separator.type, TokenType.EQ);
-    expect(constructor.initializers, isEmpty);
-    expect(constructor.redirectedConstructor, isNotNull);
-    expect(constructor.redirectedConstructor.type.name.name, 'prefix.B');
-    expect(constructor.redirectedConstructor.period.type, TokenType.PERIOD);
-    expect(constructor.redirectedConstructor.name.name, 'foo');
-    expect(constructor.body, isEmptyFunctionBody);
-  }
-
-  void test_parseClassMember_redirectingFactory_expressionBody() {
-    createParser('factory C() => throw 0;');
-    var constructor = parser.parseClassMember('C') as ConstructorDeclaration;
-    assertNoErrors();
-    expect(constructor, isNotNull);
-    expect(constructor.externalKeyword, isNull);
-    expect(constructor.constKeyword, isNull);
-    expect(constructor.factoryKeyword.keyword, Keyword.FACTORY);
-    expect(constructor.returnType.name, 'C');
-    expect(constructor.period, isNull);
-    expect(constructor.name, isNull);
-    expect(constructor.parameters, isNotNull);
-    expect(constructor.parameters.parameters, isEmpty);
-    expect(constructor.separator, isNull);
-    expect(constructor.initializers, isEmpty);
-    expect(constructor.redirectedConstructor, isNull);
-
-    var body = constructor.body as ExpressionFunctionBody;
-    expect(body.keyword, isNull);
-    expect(body.star, isNull);
-    expect(body.functionDefinition.type, TokenType.FUNCTION);
-    expect(body.expression, isNotNull);
-    expect(body.semicolon, isNotNull);
-  }
-
-  void test_parseClassMember_redirectingFactory_nonConst() {
-    createParser('factory C() = B;');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isConstructorDeclaration);
-    ConstructorDeclaration constructor = member;
-    expect(constructor.externalKeyword, isNull);
-    expect(constructor.constKeyword, isNull);
-    expect(constructor.factoryKeyword.keyword, Keyword.FACTORY);
-    expect(constructor.returnType.name, 'C');
-    _assertIsDeclarationName(constructor.returnType, false);
-    expect(constructor.period, isNull);
-    expect(constructor.name, isNull);
-    expect(constructor.parameters, isNotNull);
-    expect(constructor.parameters.parameters, isEmpty);
-    expect(constructor.separator.type, TokenType.EQ);
-    expect(constructor.initializers, isEmpty);
-    expect(constructor.redirectedConstructor, isNotNull);
-    expect(constructor.redirectedConstructor.type.name.name, 'B');
-    expect(constructor.redirectedConstructor.period, isNull);
-    expect(constructor.redirectedConstructor.name, isNull);
-    expect(constructor.body, isEmptyFunctionBody);
-  }
-
-  void test_parseConstructor_assert() {
-    createParser('C(x, y) : _x = x, assert (x < y), _y = y;');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isConstructorDeclaration);
-    ConstructorDeclaration constructor = member as ConstructorDeclaration;
-    NodeList<ConstructorInitializer> initializers = constructor.initializers;
-    expect(initializers, hasLength(3));
-    ConstructorInitializer initializer = initializers[1];
-    expect(initializer, isAssertInitializer);
-    AssertInitializer assertInitializer = initializer;
-    expect(assertInitializer.condition, isNotNull);
-    expect(assertInitializer.message, isNull);
-  }
-
-  void test_parseConstructor_factory_const_external() {
-    // Although the spec does not allow external const factory,
-    // there are several instances of this in the Dart SDK.
-    // For example `external const factory bool.fromEnvironment(...)`.
-    createParser('external const factory C();');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    assertNoErrors();
-  }
-
-  void test_parseConstructor_factory_named() {
-    createParser('factory C.foo() => throw 0;');
-    var constructor = parser.parseClassMember('C') as ConstructorDeclaration;
-    assertNoErrors();
-    expect(constructor, isNotNull);
-    expect(constructor.externalKeyword, isNull);
-    expect(constructor.constKeyword, isNull);
-    expect(constructor.factoryKeyword, isNotNull);
-    expect(constructor.returnType.name, 'C');
-    _assertIsDeclarationName(constructor.returnType, false);
-    expect(constructor.period.type, TokenType.PERIOD);
-    expect(constructor.name.name, 'foo');
-    _assertIsDeclarationName(constructor.name);
-    expect(constructor.parameters, isNotNull);
-    expect(constructor.parameters.parameters, isEmpty);
-    expect(constructor.separator, isNull);
-    expect(constructor.initializers, isEmpty);
-    expect(constructor.redirectedConstructor, isNull);
-    expect(constructor.body, isExpressionFunctionBody);
-  }
-
-  void test_parseConstructor_initializers_field() {
-    createParser('C(x, y) : _x = x, this._y = y;');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isConstructorDeclaration);
-    ConstructorDeclaration constructor = member as ConstructorDeclaration;
-    NodeList<ConstructorInitializer> initializers = constructor.initializers;
-    expect(initializers, hasLength(2));
-
-    {
-      var initializer = initializers[0] as ConstructorFieldInitializer;
-      expect(initializer.thisKeyword, isNull);
-      expect(initializer.period, isNull);
-      expect(initializer.fieldName.name, '_x');
-      expect(initializer.expression, isNotNull);
-    }
-
-    {
-      var initializer = initializers[1] as ConstructorFieldInitializer;
-      expect(initializer.thisKeyword, isNotNull);
-      expect(initializer.period, isNotNull);
-      expect(initializer.fieldName.name, '_y');
-      expect(initializer.expression, isNotNull);
-    }
-  }
-
-  void test_parseConstructor_invalidInitializer() {
-    // https://github.com/dart-lang/sdk/issues/37693
-    parseCompilationUnit('class C{ C() : super() * (); }', errors: [
-      expectedError(ParserErrorCode.INVALID_INITIALIZER, 15, 12),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 26, 1),
-    ]);
-  }
-
-  void test_parseConstructor_named() {
-    createParser('C.foo();');
-    var constructor = parser.parseClassMember('C') as ConstructorDeclaration;
-    assertNoErrors();
-    expect(constructor, isNotNull);
-    expect(constructor.externalKeyword, isNull);
-    expect(constructor.constKeyword, isNull);
-    expect(constructor.factoryKeyword, isNull);
-    expect(constructor.returnType.name, 'C');
-    _assertIsDeclarationName(constructor.returnType, false);
-    expect(constructor.period.type, TokenType.PERIOD);
-    expect(constructor.name.name, 'foo');
-    _assertIsDeclarationName(constructor.name);
-    expect(constructor.parameters, isNotNull);
-    expect(constructor.parameters.parameters, isEmpty);
-    expect(constructor.separator, isNull);
-    expect(constructor.initializers, isEmpty);
-    expect(constructor.redirectedConstructor, isNull);
-    expect(constructor.body, isEmptyFunctionBody);
-  }
-
-  void test_parseConstructor_nullSuperArgList_openBrace_37735() {
-    // https://github.com/dart-lang/sdk/issues/37735
-    var unit = parseCompilationUnit('class{const():super.{n', errors: [
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 5, 1),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 11, 1),
-      expectedError(ParserErrorCode.INVALID_CONSTRUCTOR_NAME, 11, 1),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 20, 1),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 20, 1),
-      expectedError(ParserErrorCode.CONST_CONSTRUCTOR_WITH_BODY, 20, 1),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 21, 1),
-      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 22, 1),
-      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 22, 1),
-    ]);
-    var classDeclaration = unit.declarations[0] as ClassDeclaration;
-    var constructor = classDeclaration.members[0] as ConstructorDeclaration;
-    var invocation = constructor.initializers[0] as SuperConstructorInvocation;
-    expect(invocation.argumentList.arguments, hasLength(0));
-  }
-
-  void test_parseConstructor_operator_name() {
-    var unit = parseCompilationUnit('class A { operator/() : super(); }',
-        errors: [
-          expectedError(ParserErrorCode.INVALID_CONSTRUCTOR_NAME, 10, 8)
-        ]);
-    var classDeclaration = unit.declarations[0] as ClassDeclaration;
-    var constructor = classDeclaration.members[0] as ConstructorDeclaration;
-    var invocation = constructor.initializers[0] as SuperConstructorInvocation;
-    expect(invocation.argumentList.arguments, hasLength(0));
-  }
-
-  void test_parseConstructor_superIndexed() {
-    createParser('C() : super()[];');
-    var constructor = parser.parseClassMember('C') as ConstructorDeclaration;
-    listener.assertErrors([
-      expectedError(ParserErrorCode.INVALID_SUPER_IN_INITIALIZER, 6, 5),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 14, 1),
-    ]);
-    expect(constructor, isNotNull);
-    expect(constructor.externalKeyword, isNull);
-    expect(constructor.constKeyword, isNull);
-    expect(constructor.factoryKeyword, isNull);
-    expect(constructor.returnType.name, 'C');
-    _assertIsDeclarationName(constructor.returnType, false);
-    expect(constructor.name, isNull);
-    expect(constructor.parameters, isNotNull);
-    expect(constructor.parameters.parameters, isEmpty);
-    expect(constructor.separator.lexeme, ':');
-    expect(constructor.initializers, hasLength(1));
-    SuperConstructorInvocation initializer = constructor.initializers[0];
-    expect(initializer.argumentList.arguments, isEmpty);
-    expect(constructor.redirectedConstructor, isNull);
-    expect(constructor.body, isEmptyFunctionBody);
-  }
-
-  void test_parseConstructor_thisIndexed() {
-    createParser('C() : this()[];');
-    var constructor = parser.parseClassMember('C') as ConstructorDeclaration;
-    listener.assertErrors([
-      expectedError(ParserErrorCode.INVALID_THIS_IN_INITIALIZER, 6, 4),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 13, 1),
-    ]);
-    expect(constructor, isNotNull);
-    expect(constructor.externalKeyword, isNull);
-    expect(constructor.constKeyword, isNull);
-    expect(constructor.factoryKeyword, isNull);
-    expect(constructor.returnType.name, 'C');
-    _assertIsDeclarationName(constructor.returnType, false);
-    expect(constructor.name, isNull);
-    expect(constructor.parameters, isNotNull);
-    expect(constructor.parameters.parameters, isEmpty);
-    expect(constructor.separator.lexeme, ':');
-    expect(constructor.initializers, hasLength(1));
-    RedirectingConstructorInvocation initializer = constructor.initializers[0];
-    expect(initializer.argumentList.arguments, isEmpty);
-    expect(constructor.redirectedConstructor, isNull);
-    expect(constructor.body, isEmptyFunctionBody);
-  }
-
-  void test_parseConstructor_unnamed() {
-    createParser('C();');
-    var constructor = parser.parseClassMember('C') as ConstructorDeclaration;
-    assertNoErrors();
-    expect(constructor, isNotNull);
-    expect(constructor.externalKeyword, isNull);
-    expect(constructor.constKeyword, isNull);
-    expect(constructor.factoryKeyword, isNull);
-    expect(constructor.returnType.name, 'C');
-    _assertIsDeclarationName(constructor.returnType, false);
-    expect(constructor.period, isNull);
-    expect(constructor.name, isNull);
-    expect(constructor.parameters, isNotNull);
-    expect(constructor.parameters.parameters, isEmpty);
-    expect(constructor.separator, isNull);
-    expect(constructor.initializers, isEmpty);
-    expect(constructor.redirectedConstructor, isNull);
-    expect(constructor.body, isEmptyFunctionBody);
-  }
-
-  void test_parseConstructor_with_pseudo_function_literal() {
-    // "(b) {}" should not be misinterpreted as a function literal even though
-    // it looks like one.
-    createParser('C() : a = (b) {}');
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isConstructorDeclaration);
-    ConstructorDeclaration constructor = member as ConstructorDeclaration;
-    NodeList<ConstructorInitializer> initializers = constructor.initializers;
-    expect(initializers, hasLength(1));
-    ConstructorInitializer initializer = initializers[0];
-    expect(initializer, isConstructorFieldInitializer);
-    expect((initializer as ConstructorFieldInitializer).expression,
-        isParenthesizedExpression);
-    expect(constructor.body, isBlockFunctionBody);
-  }
-
-  void test_parseConstructorFieldInitializer_qualified() {
-    var initializer = parseConstructorInitializer('this.a = b')
-        as ConstructorFieldInitializer;
-    expect(initializer, isNotNull);
-    assertNoErrors();
-    expect(initializer.equals, isNotNull);
-    expect(initializer.expression, isNotNull);
-    expect(initializer.fieldName, isNotNull);
-    expect(initializer.thisKeyword, isNotNull);
-    expect(initializer.period, isNotNull);
-  }
-
-  void test_parseConstructorFieldInitializer_unqualified() {
-    var initializer =
-        parseConstructorInitializer('a = b') as ConstructorFieldInitializer;
-    expect(initializer, isNotNull);
-    assertNoErrors();
-    expect(initializer.equals, isNotNull);
-    expect(initializer.expression, isNotNull);
-    expect(initializer.fieldName, isNotNull);
-    expect(initializer.thisKeyword, isNull);
-    expect(initializer.period, isNull);
-  }
-
-  void test_parseField_abstract() {
-    createParser('abstract int i;', featureSet: nonNullable);
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFieldDeclaration);
-    var field = member as FieldDeclaration;
-    expect(field.abstractKeyword, isNotNull);
-  }
-
-  void test_parseField_abstract_external() {
-    createParser('abstract external int i;', featureSet: nonNullable);
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertErrors(errors: [
-      expectedError(ParserErrorCode.ABSTRACT_EXTERNAL_FIELD, 0, 8),
-    ]);
-    expect(member, isFieldDeclaration);
-    var field = member as FieldDeclaration;
-    expect(field.abstractKeyword, isNotNull);
-    expect(field.externalKeyword, isNotNull);
-  }
-
-  void test_parseField_abstract_late() {
-    createParser('abstract late int? i;', featureSet: nonNullable);
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertErrors(errors: [
-      expectedError(ParserErrorCode.ABSTRACT_LATE_FIELD, 0, 8),
-    ]);
-    expect(member, isFieldDeclaration);
-    var field = member as FieldDeclaration;
-    expect(field.abstractKeyword, isNotNull);
-  }
-
-  void test_parseField_abstract_late_final() {
-    createParser('abstract late final int? i;', featureSet: nonNullable);
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertErrors(errors: [
-      expectedError(ParserErrorCode.ABSTRACT_LATE_FIELD, 0, 8),
-    ]);
-    expect(member, isFieldDeclaration);
-    var field = member as FieldDeclaration;
-    expect(field.abstractKeyword, isNotNull);
-  }
-
-  void test_parseField_abstract_static() {
-    createParser('abstract static int? i;', featureSet: nonNullable);
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertErrors(errors: [
-      expectedError(ParserErrorCode.ABSTRACT_STATIC_FIELD, 0, 8),
-    ]);
-    expect(member, isFieldDeclaration);
-    var field = member as FieldDeclaration;
-    expect(field.abstractKeyword, isNotNull);
-  }
-
-  void test_parseField_const_late() {
-    createParser('const late T f = 0;', featureSet: nonNullable);
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertErrors(errors: [
-      expectedError(ParserErrorCode.CONFLICTING_MODIFIERS, 6, 4),
-    ]);
-    expect(member, isFieldDeclaration);
-    var field = member as FieldDeclaration;
-    expect(field.covariantKeyword, isNull);
-    expect(field.documentationComment, isNull);
-    expect(field.metadata, hasLength(0));
-    expect(field.staticKeyword, isNull);
-    VariableDeclarationList list = field.fields;
-    expect(list, isNotNull);
-    expect(list.keyword, isNotNull);
-    expect(list.isConst, isTrue);
-    expect(list.isFinal, isFalse);
-    expect(list.isLate, isTrue);
-    expect(list.lateKeyword, isNotNull);
-    NodeList<VariableDeclaration> variables = list.variables;
-    expect(variables, hasLength(1));
-    VariableDeclaration variable = variables[0];
-    expect(variable.name, isNotNull);
-  }
-
-  void test_parseField_external() {
-    createParser('external int i;', featureSet: nonNullable);
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFieldDeclaration);
-    var field = member as FieldDeclaration;
-    expect(field.externalKeyword, isNotNull);
-  }
-
-  void test_parseField_external_abstract() {
-    createParser('external abstract int i;', featureSet: nonNullable);
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertErrors(errors: [
-      expectedError(ParserErrorCode.ABSTRACT_EXTERNAL_FIELD, 9, 8),
-    ]);
-    expect(member, isFieldDeclaration);
-    var field = member as FieldDeclaration;
-    expect(field.abstractKeyword, isNotNull);
-    expect(field.externalKeyword, isNotNull);
-  }
-
-  void test_parseField_external_late() {
-    createParser('external late int? i;', featureSet: nonNullable);
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertErrors(errors: [
-      expectedError(ParserErrorCode.EXTERNAL_LATE_FIELD, 0, 8),
-    ]);
-    expect(member, isFieldDeclaration);
-    var field = member as FieldDeclaration;
-    expect(field.externalKeyword, isNotNull);
-  }
-
-  void test_parseField_external_late_final() {
-    createParser('external late final int? i;', featureSet: nonNullable);
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertErrors(errors: [
-      expectedError(ParserErrorCode.EXTERNAL_LATE_FIELD, 0, 8),
-    ]);
-    expect(member, isFieldDeclaration);
-    var field = member as FieldDeclaration;
-    expect(field.externalKeyword, isNotNull);
-  }
-
-  void test_parseField_external_static() {
-    createParser('external static int? i;', featureSet: nonNullable);
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFieldDeclaration);
-    var field = member as FieldDeclaration;
-    expect(field.externalKeyword, isNotNull);
-  }
-
-  void test_parseField_final_late() {
-    createParser('final late T f;', featureSet: nonNullable);
-    ClassMember member = parser.parseClassMember('C');
-    assertErrors(errors: [
-      expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 6, 4),
-    ]);
-    expect(member, isNotNull);
-    expect(member, isFieldDeclaration);
-    var field = member as FieldDeclaration;
-    expect(field.covariantKeyword, isNull);
-    expect(field.documentationComment, isNull);
-    expect(field.metadata, hasLength(0));
-    expect(field.staticKeyword, isNull);
-    VariableDeclarationList list = field.fields;
-    expect(list, isNotNull);
-    expect(list.keyword, isNotNull);
-    expect(list.isConst, isFalse);
-    expect(list.isFinal, isTrue);
-    expect(list.isLate, isTrue);
-    expect(list.lateKeyword, isNotNull);
-    NodeList<VariableDeclaration> variables = list.variables;
-    expect(variables, hasLength(1));
-    VariableDeclaration variable = variables[0];
-    expect(variable.name, isNotNull);
-  }
-
-  void test_parseField_late() {
-    createParser('late T f;', featureSet: nonNullable);
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFieldDeclaration);
-    var field = member as FieldDeclaration;
-    expect(field.covariantKeyword, isNull);
-    expect(field.documentationComment, isNull);
-    expect(field.metadata, hasLength(0));
-    expect(field.staticKeyword, isNull);
-    VariableDeclarationList list = field.fields;
-    expect(list, isNotNull);
-    expect(list.keyword, isNull);
-    expect(list.isConst, isFalse);
-    expect(list.isFinal, isFalse);
-    expect(list.isLate, isTrue);
-    expect(list.lateKeyword, isNotNull);
-    NodeList<VariableDeclaration> variables = list.variables;
-    expect(variables, hasLength(1));
-    VariableDeclaration variable = variables[0];
-    expect(variable.name, isNotNull);
-  }
-
-  void test_parseField_late_const() {
-    createParser('late const T f = 0;', featureSet: nonNullable);
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertErrors(errors: [
-      expectedError(ParserErrorCode.CONFLICTING_MODIFIERS, 5, 5),
-    ]);
-    expect(member, isFieldDeclaration);
-    var field = member as FieldDeclaration;
-    expect(field.covariantKeyword, isNull);
-    expect(field.documentationComment, isNull);
-    expect(field.metadata, hasLength(0));
-    expect(field.staticKeyword, isNull);
-    VariableDeclarationList list = field.fields;
-    expect(list, isNotNull);
-    expect(list.keyword, isNotNull);
-    expect(list.isConst, isTrue);
-    expect(list.isFinal, isFalse);
-    expect(list.isLate, isTrue);
-    expect(list.lateKeyword, isNotNull);
-    NodeList<VariableDeclaration> variables = list.variables;
-    expect(variables, hasLength(1));
-    VariableDeclaration variable = variables[0];
-    expect(variable.name, isNotNull);
-  }
-
-  void test_parseField_late_final() {
-    createParser('late final T f;', featureSet: nonNullable);
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFieldDeclaration);
-    var field = member as FieldDeclaration;
-    expect(field.covariantKeyword, isNull);
-    expect(field.documentationComment, isNull);
-    expect(field.metadata, hasLength(0));
-    expect(field.staticKeyword, isNull);
-    VariableDeclarationList list = field.fields;
-    expect(list, isNotNull);
-    expect(list.keyword, isNotNull);
-    expect(list.isConst, isFalse);
-    expect(list.isFinal, isTrue);
-    expect(list.isLate, isTrue);
-    expect(list.lateKeyword, isNotNull);
-    NodeList<VariableDeclaration> variables = list.variables;
-    expect(variables, hasLength(1));
-    VariableDeclaration variable = variables[0];
-    expect(variable.name, isNotNull);
-  }
-
-  void test_parseField_late_var() {
-    createParser('late var f;', featureSet: nonNullable);
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    expect(member, isFieldDeclaration);
-    var field = member as FieldDeclaration;
-    expect(field.covariantKeyword, isNull);
-    expect(field.documentationComment, isNull);
-    expect(field.metadata, hasLength(0));
-    expect(field.staticKeyword, isNull);
-    VariableDeclarationList list = field.fields;
-    expect(list, isNotNull);
-    expect(list.keyword, isNotNull);
-    expect(list.isConst, isFalse);
-    expect(list.isFinal, isFalse);
-    expect(list.isLate, isTrue);
-    expect(list.lateKeyword, isNotNull);
-    NodeList<VariableDeclaration> variables = list.variables;
-    expect(variables, hasLength(1));
-    VariableDeclaration variable = variables[0];
-    expect(variable.name, isNotNull);
-  }
-
-  void test_parseField_non_abstract() {
-    createParser('int i;', featureSet: nonNullable);
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFieldDeclaration);
-    var field = member as FieldDeclaration;
-    expect(field.abstractKeyword, isNull);
-  }
-
-  void test_parseField_non_external() {
-    createParser('int i;', featureSet: nonNullable);
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFieldDeclaration);
-    var field = member as FieldDeclaration;
-    expect(field.externalKeyword, isNull);
-  }
-
-  void test_parseField_var_late() {
-    createParser('var late f;', featureSet: nonNullable);
-    ClassMember member = parser.parseClassMember('C');
-    expect(member, isNotNull);
-    assertErrors(errors: [
-      expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 4, 4),
-    ]);
-    expect(member, isFieldDeclaration);
-    var field = member as FieldDeclaration;
-    expect(field.covariantKeyword, isNull);
-    expect(field.documentationComment, isNull);
-    expect(field.metadata, hasLength(0));
-    expect(field.staticKeyword, isNull);
-    VariableDeclarationList list = field.fields;
-    expect(list, isNotNull);
-    expect(list.keyword, isNotNull);
-    expect(list.isConst, isFalse);
-    expect(list.isFinal, isFalse);
-    expect(list.isLate, isTrue);
-    expect(list.lateKeyword, isNotNull);
-    NodeList<VariableDeclaration> variables = list.variables;
-    expect(variables, hasLength(1));
-    VariableDeclaration variable = variables[0];
-    expect(variable.name, isNotNull);
-  }
-
-  void test_parseGetter_identifier_colon_issue_36961() {
-    createParser('get a:');
-    ConstructorDeclaration constructor = parser.parseClassMember('C');
-    expect(constructor, isNotNull);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.GETTER_CONSTRUCTOR, 0, 3),
-      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 4, 1),
-      expectedError(ParserErrorCode.INVALID_CONSTRUCTOR_NAME, 4, 1),
-      expectedError(ParserErrorCode.MISSING_INITIALIZER, 5, 1),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 6, 0),
-    ]);
-    expect(constructor.body, isNotNull);
-    expect(constructor.documentationComment, isNull);
-    expect(constructor.externalKeyword, isNull);
-    expect(constructor.name, isNull);
-    expect(constructor.parameters, isNotNull);
-    expect(constructor.returnType, isNotNull);
-  }
-
-  void test_parseGetter_nonStatic() {
-    createParser('/// Doc\nT get a;');
-    MethodDeclaration method = parser.parseClassMember('C');
-    expect(method, isNotNull);
-    assertNoErrors();
-    expect(method.body, isNotNull);
-    expectCommentText(method.documentationComment, '/// Doc');
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.parameters, isNull);
-    expect(method.propertyKeyword, isNotNull);
-    expect((method.returnType as TypeName).name.name, 'T');
-  }
-
-  void test_parseGetter_static() {
-    createParser('/// Doc\nstatic T get a => 42;');
-    MethodDeclaration method = parser.parseClassMember('C');
-    expect(method, isNotNull);
-    assertNoErrors();
-    expect(method.body, isNotNull);
-    expectCommentText(method.documentationComment, '/// Doc');
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword.lexeme, 'static');
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNull);
-    expect(method.propertyKeyword, isNotNull);
-    expect((method.returnType as TypeName).name.name, 'T');
-  }
-
-  void test_parseInitializedIdentifierList_type() {
-    createParser("/// Doc\nstatic T a = 1, b, c = 3;");
-    FieldDeclaration declaration = parser.parseClassMember('C');
-    expect(declaration, isNotNull);
-    assertNoErrors();
-    expectCommentText(declaration.documentationComment, '/// Doc');
-    VariableDeclarationList fields = declaration.fields;
-    expect(fields, isNotNull);
-    expect(fields.keyword, isNull);
-    expect((fields.type as TypeName).name.name, 'T');
-    expect(fields.variables, hasLength(3));
-    expect(declaration.staticKeyword.lexeme, 'static');
-    expect(declaration.semicolon, isNotNull);
-  }
-
-  void test_parseInitializedIdentifierList_var() {
-    createParser('/// Doc\nstatic var a = 1, b, c = 3;');
-    FieldDeclaration declaration = parser.parseClassMember('C');
-    expect(declaration, isNotNull);
-    assertNoErrors();
-    expectCommentText(declaration.documentationComment, '/// Doc');
-    VariableDeclarationList fields = declaration.fields;
-    expect(fields, isNotNull);
-    expect(fields.keyword.lexeme, 'var');
-    expect(fields.type, isNull);
-    expect(fields.variables, hasLength(3));
-    expect(declaration.staticKeyword.lexeme, 'static');
-    expect(declaration.semicolon, isNotNull);
-  }
-
-  void test_parseOperator() {
-    createParser('/// Doc\nT operator +(A a);');
-    MethodDeclaration method = parser.parseClassMember('C');
-    expect(method, isNotNull);
-    assertNoErrors();
-    expect(method.body, isNotNull);
-    expectCommentText(method.documentationComment, '/// Doc');
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNotNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.propertyKeyword, isNull);
-    expect((method.returnType as TypeName).name.name, 'T');
-  }
-
-  void test_parseSetter_nonStatic() {
-    createParser('/// Doc\nT set a(var x);');
-    MethodDeclaration method = parser.parseClassMember('C');
-    expect(method, isNotNull);
-    assertNoErrors();
-    expect(method.body, isNotNull);
-    expectCommentText(method.documentationComment, '/// Doc');
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword, isNull);
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.propertyKeyword, isNotNull);
-    expect((method.returnType as TypeName).name.name, 'T');
-  }
-
-  void test_parseSetter_static() {
-    createParser('/// Doc\nstatic T set a(var x) {}');
-    MethodDeclaration method = parser.parseClassMember('C');
-    expect(method, isNotNull);
-    assertNoErrors();
-    expect(method.body, isNotNull);
-    expectCommentText(method.documentationComment, '/// Doc');
-    expect(method.externalKeyword, isNull);
-    expect(method.modifierKeyword.lexeme, 'static');
-    expect(method.name, isNotNull);
-    expect(method.operatorKeyword, isNull);
-    expect(method.typeParameters, isNull);
-    expect(method.parameters, isNotNull);
-    expect(method.propertyKeyword, isNotNull);
-    expect((method.returnType as TypeName).name.name, 'T');
-  }
-
-  void test_simpleFormalParameter_withDocComment() {
-    createParser('''
-int f(
-    /// Doc
-    int x) {}
-''');
-    var function = parseFullCompilationUnitMember() as FunctionDeclaration;
-    var parameter = function.functionExpression.parameters.parameters[0]
-        as NormalFormalParameter;
-    expectCommentText(parameter.documentationComment, '/// Doc');
-  }
-
-  /// Assert that the given [name] is in declaration context.
-  void _assertIsDeclarationName(SimpleIdentifier name, [bool expected = true]) {
-    expect(name.inDeclarationContext(), expected);
-  }
-
-  void _parseClassMember_method_native() {
-    createParser('m() native "str";');
-    var method = parser.parseClassMember('C') as MethodDeclaration;
-    var body = method.body as NativeFunctionBody;
-    expect(body.nativeKeyword, isNotNull);
-    expect(body.stringLiteral, isNotNull);
-    expect(body.stringLiteral?.stringValue, "str");
-    expect(body.semicolon, isNotNull);
-  }
-
-  void _parseClassMember_method_native_missing_literal() {
-    createParser('m() native;');
-    var method = parser.parseClassMember('C') as MethodDeclaration;
-    var body = method.body as NativeFunctionBody;
-    expect(body.nativeKeyword, isNotNull);
-    expect(body.stringLiteral, isNull);
-    expect(body.semicolon, isNotNull);
-  }
-
-  void _parseClassMember_method_native_with_body() {
-    createParser('m() native "str" {}');
-    parser.parseClassMember('C') as MethodDeclaration;
-  }
-}
-
-/// The class `ComplexParserTest` defines parser tests that test the parsing of
-/// more complex code fragments or the interactions between multiple parsing
-/// methods. For example, tests to ensure that the precedence of operations is
-/// being handled correctly should be defined in this class.
-///
-/// Simpler tests should be defined in the class [SimpleParserTest].
-@reflectiveTest
-class ComplexParserTest extends FastaParserTestCase {
-  void test_additiveExpression_normal() {
-    BinaryExpression expression = parseExpression("x + y - z");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_additiveExpression_noSpaces() {
-    BinaryExpression expression = parseExpression("i+1");
-    expect(expression.leftOperand, isSimpleIdentifier);
-    expect(expression.rightOperand, isIntegerLiteral);
-  }
-
-  void test_additiveExpression_precedence_multiplicative_left() {
-    BinaryExpression expression = parseExpression("x * y + z");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_additiveExpression_precedence_multiplicative_left_withSuper() {
-    BinaryExpression expression = parseExpression("super * y - z");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_additiveExpression_precedence_multiplicative_right() {
-    BinaryExpression expression = parseExpression("x + y * z");
-    expect(expression.rightOperand, isBinaryExpression);
-  }
-
-  void test_additiveExpression_super() {
-    BinaryExpression expression = parseExpression("super + y - z");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_assignableExpression_arguments_normal_chain() {
-    PropertyAccess propertyAccess1 = parseExpression("a(b)(c).d(e).f");
-    expect(propertyAccess1.propertyName.name, "f");
-    //
-    // a(b)(c).d(e)
-    //
-    MethodInvocation invocation2 = propertyAccess1.target;
-    expect(invocation2.methodName.name, "d");
-    expect(invocation2.typeArguments, isNull);
-    ArgumentList argumentList2 = invocation2.argumentList;
-    expect(argumentList2, isNotNull);
-    expect(argumentList2.arguments, hasLength(1));
-    //
-    // a(b)(c)
-    //
-    FunctionExpressionInvocation invocation3 = invocation2.target;
-    expect(invocation3.typeArguments, isNull);
-    ArgumentList argumentList3 = invocation3.argumentList;
-    expect(argumentList3, isNotNull);
-    expect(argumentList3.arguments, hasLength(1));
-    //
-    // a(b)
-    //
-    MethodInvocation invocation4 = invocation3.function;
-    expect(invocation4.methodName.name, "a");
-    expect(invocation4.typeArguments, isNull);
-    ArgumentList argumentList4 = invocation4.argumentList;
-    expect(argumentList4, isNotNull);
-    expect(argumentList4.arguments, hasLength(1));
-  }
-
-  void test_assignableExpression_arguments_normal_chain_typeArguments() {
-    _validate_assignableExpression_arguments_normal_chain_typeArguments(
-        "a<E>(b)<F>(c).d<G>(e).f");
-  }
-
-  void test_assignmentExpression_compound() {
-    AssignmentExpression expression = parseExpression("x = y = 0");
-    expect(expression.leftHandSide, isSimpleIdentifier);
-    expect(expression.rightHandSide, isAssignmentExpression);
-  }
-
-  void test_assignmentExpression_indexExpression() {
-    AssignmentExpression expression = parseExpression("x[1] = 0");
-    expect(expression.leftHandSide, isIndexExpression);
-    expect(expression.rightHandSide, isIntegerLiteral);
-  }
-
-  void test_assignmentExpression_prefixedIdentifier() {
-    AssignmentExpression expression = parseExpression("x.y = 0");
-    expect(expression.leftHandSide, isPrefixedIdentifier);
-    expect(expression.rightHandSide, isIntegerLiteral);
-  }
-
-  void test_assignmentExpression_propertyAccess() {
-    AssignmentExpression expression = parseExpression("super.y = 0");
-    expect(expression.leftHandSide, isPropertyAccess);
-    expect(expression.rightHandSide, isIntegerLiteral);
-  }
-
-  void test_binary_operator_written_out_expression() {
-    var expression = parseExpression('x xor y', errors: [
-      expectedError(ParserErrorCode.BINARY_OPERATOR_WRITTEN_OUT, 2, 3),
-    ]) as BinaryExpression;
-    var lhs = expression.leftOperand as SimpleIdentifier;
-    expect(lhs.name, 'x');
-    expect(expression.operator.lexeme, '^');
-    var rhs = expression.rightOperand as SimpleIdentifier;
-    expect(rhs.name, 'y');
-  }
-
-  void test_bitwiseAndExpression_normal() {
-    BinaryExpression expression = parseExpression("x & y & z");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_bitwiseAndExpression_precedence_equality_left() {
-    BinaryExpression expression = parseExpression("x == y && z");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_bitwiseAndExpression_precedence_equality_right() {
-    BinaryExpression expression = parseExpression("x && y == z");
-    expect(expression.rightOperand, isBinaryExpression);
-  }
-
-  void test_bitwiseAndExpression_super() {
-    BinaryExpression expression = parseExpression("super & y & z");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_bitwiseOrExpression_normal() {
-    BinaryExpression expression = parseExpression("x | y | z");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_bitwiseOrExpression_precedence_xor_left() {
-    BinaryExpression expression = parseExpression("x ^ y | z");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_bitwiseOrExpression_precedence_xor_right() {
-    BinaryExpression expression = parseExpression("x | y ^ z");
-    expect(expression.rightOperand, isBinaryExpression);
-  }
-
-  void test_bitwiseOrExpression_super() {
-    BinaryExpression expression = parseExpression("super | y | z");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_bitwiseXorExpression_normal() {
-    BinaryExpression expression = parseExpression("x ^ y ^ z");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_bitwiseXorExpression_precedence_and_left() {
-    BinaryExpression expression = parseExpression("x & y ^ z");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_bitwiseXorExpression_precedence_and_right() {
-    BinaryExpression expression = parseExpression("x ^ y & z");
-    expect(expression.rightOperand, isBinaryExpression);
-  }
-
-  void test_bitwiseXorExpression_super() {
-    BinaryExpression expression = parseExpression("super ^ y ^ z");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_cascade_withAssignment() {
-    CascadeExpression cascade =
-        parseExpression("new Map()..[3] = 4 ..[0] = 11");
-    Expression target = cascade.target;
-    for (Expression section in cascade.cascadeSections) {
-      expect(section, isAssignmentExpression);
-      Expression lhs = (section as AssignmentExpression).leftHandSide;
-      expect(lhs, isIndexExpression);
-      IndexExpression index = lhs as IndexExpression;
-      expect(index.isCascaded, isTrue);
-      expect(index.realTarget, same(target));
-    }
-  }
-
-  void test_conditionalExpression_precedence_ifNullExpression() {
-    ConditionalExpression expression = parseExpression('a ?? b ? y : z');
-    expect(expression.condition, isBinaryExpression);
-  }
-
-  void test_conditionalExpression_precedence_logicalOrExpression() {
-    ConditionalExpression expression = parseExpression("a | b ? y : z");
-    expect(expression.condition, isBinaryExpression);
-  }
-
-  void test_conditionalExpression_precedence_nullableType_as() {
-    ExpressionStatement statement = parseStatement('x as bool ? (x + y) : z;');
-    ConditionalExpression expression = statement.expression;
-    Expression condition = expression.condition;
-    expect(condition, isAsExpression);
-    Expression thenExpression = expression.thenExpression;
-    expect(thenExpression, isParenthesizedExpression);
-    Expression elseExpression = expression.elseExpression;
-    expect(elseExpression, isSimpleIdentifier);
-  }
-
-  void test_conditionalExpression_precedence_nullableType_as2() {
-    var statement =
-        parseStatement('x as bool? ? (x + y) : z;') as ExpressionStatement;
-    var expression = statement.expression as ConditionalExpression;
-    var asExpression = expression.condition as AsExpression;
-    var type = asExpression.type as TypeName;
-    expect(type.question.lexeme, '?');
-    Expression thenExpression = expression.thenExpression;
-    expect(thenExpression, isParenthesizedExpression);
-    Expression elseExpression = expression.elseExpression;
-    expect(elseExpression, isSimpleIdentifier);
-    assertNoErrors();
-  }
-
-  void test_conditionalExpression_precedence_nullableType_as3() {
-    var statement =
-        parseStatement('(x as bool?) ? (x + y) : z;') as ExpressionStatement;
-    var expression = statement.expression as ConditionalExpression;
-    var condition = expression.condition as ParenthesizedExpression;
-    var asExpression = condition.expression as AsExpression;
-    var type = asExpression.type as TypeName;
-    expect(type.question.lexeme, '?');
-    Expression thenExpression = expression.thenExpression;
-    expect(thenExpression, isParenthesizedExpression);
-    Expression elseExpression = expression.elseExpression;
-    expect(elseExpression, isSimpleIdentifier);
-    assertNoErrors();
-  }
-
-  void test_conditionalExpression_precedence_nullableType_is() {
-    ExpressionStatement statement =
-        parseStatement('x is String ? (x + y) : z;');
-    ConditionalExpression expression = statement.expression;
-    Expression condition = expression.condition;
-    expect(condition, isIsExpression);
-    Expression thenExpression = expression.thenExpression;
-    expect(thenExpression, isParenthesizedExpression);
-    Expression elseExpression = expression.elseExpression;
-    expect(elseExpression, isSimpleIdentifier);
-  }
-
-  void test_conditionalExpression_precedence_nullableType_is2() {
-    var statement =
-        parseStatement('x is String? ? (x + y) : z;') as ExpressionStatement;
-    var expression = statement.expression as ConditionalExpression;
-    var isExpression = expression.condition as IsExpression;
-    var type = isExpression.type as TypeName;
-    expect(type.question.lexeme, '?');
-    Expression thenExpression = expression.thenExpression;
-    expect(thenExpression, isParenthesizedExpression);
-    Expression elseExpression = expression.elseExpression;
-    expect(elseExpression, isSimpleIdentifier);
-    assertNoErrors();
-  }
-
-  void test_conditionalExpression_precedence_nullableType_is3() {
-    var statement =
-        parseStatement('(x is String?) ? (x + y) : z;') as ExpressionStatement;
-    var expression = statement.expression as ConditionalExpression;
-    var condition = expression.condition as ParenthesizedExpression;
-    var isExpression = condition.expression as IsExpression;
-    var type = isExpression.type as TypeName;
-    expect(type.question.lexeme, '?');
-    Expression thenExpression = expression.thenExpression;
-    expect(thenExpression, isParenthesizedExpression);
-    Expression elseExpression = expression.elseExpression;
-    expect(elseExpression, isSimpleIdentifier);
-    assertNoErrors();
-  }
-
-  void test_conditionalExpression_precedence_nullableTypeWithTypeArg1_is() {
-    ExpressionStatement statement =
-        parseStatement('x is String<S> ? (x + y) : z;');
-    ConditionalExpression expression = statement.expression;
-    Expression condition = expression.condition;
-    expect(condition, TypeMatcher<IsExpression>());
-    Expression thenExpression = expression.thenExpression;
-    expect(thenExpression, TypeMatcher<ParenthesizedExpression>());
-    Expression elseExpression = expression.elseExpression;
-    expect(elseExpression, TypeMatcher<SimpleIdentifier>());
-  }
-
-  void test_conditionalExpression_precedence_nullableTypeWithTypeArg1GFT_is() {
-    ExpressionStatement statement =
-        parseStatement('x is String<S> Function() ? (x + y) : z;');
-    ConditionalExpression expression = statement.expression;
-    Expression condition = expression.condition;
-    expect(condition, TypeMatcher<IsExpression>());
-    Expression thenExpression = expression.thenExpression;
-    expect(thenExpression, TypeMatcher<ParenthesizedExpression>());
-    Expression elseExpression = expression.elseExpression;
-    expect(elseExpression, TypeMatcher<SimpleIdentifier>());
-  }
-
-  void test_conditionalExpression_precedence_nullableTypeWithTypeArg2_is() {
-    ExpressionStatement statement =
-        parseStatement('x is String<S,T> ? (x + y) : z;');
-    ConditionalExpression expression = statement.expression;
-    Expression condition = expression.condition;
-    expect(condition, TypeMatcher<IsExpression>());
-    Expression thenExpression = expression.thenExpression;
-    expect(thenExpression, TypeMatcher<ParenthesizedExpression>());
-    Expression elseExpression = expression.elseExpression;
-    expect(elseExpression, TypeMatcher<SimpleIdentifier>());
-  }
-
-  void test_conditionalExpression_precedence_prefixedNullableType_is() {
-    ExpressionStatement statement = parseStatement('x is p.A ? (x + y) : z;');
-    ConditionalExpression expression = statement.expression;
-
-    Expression condition = expression.condition;
-    expect(condition, TypeMatcher<IsExpression>());
-    Expression thenExpression = expression.thenExpression;
-    expect(thenExpression, TypeMatcher<ParenthesizedExpression>());
-    Expression elseExpression = expression.elseExpression;
-    expect(elseExpression, TypeMatcher<SimpleIdentifier>());
-  }
-
-  void test_conditionalExpression_precedence_withAssignment() {
-    ExpressionStatement statement = parseStatement('b ? c = true : g();');
-    ConditionalExpression expression = statement.expression;
-    expect(expression.condition, TypeMatcher<SimpleIdentifier>());
-    expect(expression.thenExpression, TypeMatcher<AssignmentExpression>());
-  }
-
-  void test_conditionalExpression_precedence_withAssignment2() {
-    ExpressionStatement statement = parseStatement('b.x ? c = true : g();');
-    ConditionalExpression expression = statement.expression;
-    expect(expression.condition, TypeMatcher<PrefixedIdentifier>());
-    expect(expression.thenExpression, TypeMatcher<AssignmentExpression>());
-  }
-
-  void test_conditionalExpression_prefixedValue() {
-    ExpressionStatement statement = parseStatement('a.b ? y : z;');
-    ConditionalExpression expression = statement.expression;
-    expect(expression.condition, TypeMatcher<PrefixedIdentifier>());
-    expect(expression.thenExpression, TypeMatcher<SimpleIdentifier>());
-  }
-
-  void test_conditionalExpression_prefixedValue2() {
-    ExpressionStatement statement = parseStatement('a.b ? x.y : z;');
-    ConditionalExpression expression = statement.expression;
-    expect(expression.condition, TypeMatcher<PrefixedIdentifier>());
-    expect(expression.thenExpression, TypeMatcher<PrefixedIdentifier>());
-  }
-
-  void test_constructor_initializer_withParenthesizedExpression() {
-    CompilationUnit unit = parseCompilationUnit(r'''
-class C {
-  C() :
-    this.a = (b == null ? c : d) {
-  }
-}''');
-    NodeList<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(1));
-  }
-
-  void test_equalityExpression_normal() {
-    BinaryExpression expression = parseExpression("x == y != z",
-        codes: [ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND]);
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_equalityExpression_precedence_relational_left() {
-    BinaryExpression expression = parseExpression("x is y == z");
-    expect(expression.leftOperand, isIsExpression);
-  }
-
-  void test_equalityExpression_precedence_relational_right() {
-    BinaryExpression expression = parseExpression("x == y is z");
-    expect(expression.rightOperand, isIsExpression);
-  }
-
-  void test_equalityExpression_super() {
-    BinaryExpression expression = parseExpression("super == y != z",
-        codes: [ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND]);
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_ifNullExpression() {
-    BinaryExpression expression = parseExpression('x ?? y ?? z');
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_ifNullExpression_precedence_logicalOr_left() {
-    BinaryExpression expression = parseExpression('x || y ?? z');
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_ifNullExpression_precedence_logicalOr_right() {
-    BinaryExpression expression = parseExpression('x ?? y || z');
-    expect(expression.rightOperand, isBinaryExpression);
-  }
-
-  void test_logicalAndExpression() {
-    BinaryExpression expression = parseExpression("x && y && z");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_logicalAndExpression_precedence_bitwiseOr_left() {
-    BinaryExpression expression = parseExpression("x | y < z");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_logicalAndExpression_precedence_bitwiseOr_right() {
-    BinaryExpression expression = parseExpression("x < y | z");
-    expect(expression.rightOperand, isBinaryExpression);
-  }
-
-  void test_logicalAndExpressionStatement() {
-    // Assert that `<` and `>` are not interpreted as type arguments.
-    ExpressionStatement statement = parseStatement("C<T && T>U;");
-    BinaryExpression expression = statement.expression;
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_logicalOrExpression() {
-    BinaryExpression expression = parseExpression("x || y || z");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_logicalOrExpression_precedence_logicalAnd_left() {
-    BinaryExpression expression = parseExpression("x && y || z");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_logicalOrExpression_precedence_logicalAnd_right() {
-    BinaryExpression expression = parseExpression("x || y && z");
-    expect(expression.rightOperand, isBinaryExpression);
-  }
-
-  void test_methodInvocation1() {
-    // Assert that `<` and `>` are not interpreted as type arguments.
-    ExpressionStatement statement = parseStatement("f(a < b, c > 3);");
-    assertNoErrors();
-    MethodInvocation method = statement.expression;
-    expect(method.argumentList.arguments, hasLength(2));
-  }
-
-  void test_methodInvocation2() {
-    // Assert that `<` and `>` are not interpreted as type arguments.
-    ExpressionStatement statement = parseStatement("f(a < b, c >> 3);");
-    assertNoErrors();
-    MethodInvocation method = statement.expression;
-    expect(method.argumentList.arguments, hasLength(2));
-  }
-
-  void test_methodInvocation3() {
-    // Assert that `<` and `>` are not interpreted as type arguments.
-    ExpressionStatement statement = parseStatement("f(a < b, c < d >> 3);");
-    assertNoErrors();
-    MethodInvocation method = statement.expression;
-    expect(method.argumentList.arguments, hasLength(2));
-  }
-
-  void test_multipleLabels_statement() {
-    LabeledStatement statement = parseStatement("a: b: c: return x;");
-    expect(statement.labels, hasLength(3));
-    expect(statement.statement, isReturnStatement);
-  }
-
-  void test_multiplicativeExpression_normal() {
-    BinaryExpression expression = parseExpression("x * y / z");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_multiplicativeExpression_precedence_unary_left() {
-    BinaryExpression expression = parseExpression("-x * y");
-    expect(expression.leftOperand, isPrefixExpression);
-  }
-
-  void test_multiplicativeExpression_precedence_unary_right() {
-    BinaryExpression expression = parseExpression("x * -y");
-    expect(expression.rightOperand, isPrefixExpression);
-  }
-
-  void test_multiplicativeExpression_super() {
-    BinaryExpression expression = parseExpression("super * y / z");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_relationalExpression_precedence_shift_right() {
-    IsExpression expression = parseExpression("x << y is z");
-    expect(expression.expression, isBinaryExpression);
-  }
-
-  void test_shiftExpression_normal() {
-    BinaryExpression expression = parseExpression("x >> 4 << 3");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_shiftExpression_precedence_additive_left() {
-    BinaryExpression expression = parseExpression("x + y << z");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_shiftExpression_precedence_additive_right() {
-    BinaryExpression expression = parseExpression("x << y + z");
-    expect(expression.rightOperand, isBinaryExpression);
-  }
-
-  void test_shiftExpression_super() {
-    BinaryExpression expression = parseExpression("super >> 4 << 3");
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_topLevelFunction_nestedGenericFunction() {
-    parseCompilationUnit('''
-void f() {
-  void g<T>() {
-  }
-}
-''');
-  }
-
-  void _validate_assignableExpression_arguments_normal_chain_typeArguments(
-      String code,
-      [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
-    PropertyAccess propertyAccess1 = parseExpression(code, codes: errorCodes);
-    expect(propertyAccess1.propertyName.name, "f");
-    //
-    // a<E>(b)<F>(c).d<G>(e)
-    //
-    MethodInvocation invocation2 = propertyAccess1.target;
-    expect(invocation2.methodName.name, "d");
-    expect(invocation2.typeArguments, isNotNull);
-    ArgumentList argumentList2 = invocation2.argumentList;
-    expect(argumentList2, isNotNull);
-    expect(argumentList2.arguments, hasLength(1));
-    //
-    // a<E>(b)<F>(c)
-    //
-    FunctionExpressionInvocation invocation3 = invocation2.target;
-    expect(invocation3.typeArguments, isNotNull);
-    ArgumentList argumentList3 = invocation3.argumentList;
-    expect(argumentList3, isNotNull);
-    expect(argumentList3.arguments, hasLength(1));
-    //
-    // a(b)
-    //
-    MethodInvocation invocation4 = invocation3.function;
-    expect(invocation4.methodName.name, "a");
-    expect(invocation4.typeArguments, isNotNull);
-    ArgumentList argumentList4 = invocation4.argumentList;
-    expect(argumentList4, isNotNull);
-    expect(argumentList4.arguments, hasLength(1));
-  }
-}
-
-/// This defines parser tests that test the parsing of code to ensure that
-/// errors are correctly reported, and in some cases, not reported.
-@reflectiveTest
-class ErrorParserTest extends FastaParserTestCase {
-  void test_abstractClassMember_constructor() {
-    createParser('abstract C.c();');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.ABSTRACT_CLASS_MEMBER, 0, 8)]);
-  }
-
-  void test_abstractClassMember_field() {
-    createParser('abstract C f;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    assertNoErrors();
-  }
-
-  void test_abstractClassMember_getter() {
-    createParser('abstract get m;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.ABSTRACT_CLASS_MEMBER, 0, 8)]);
-  }
-
-  void test_abstractClassMember_method() {
-    createParser('abstract m();');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.ABSTRACT_CLASS_MEMBER, 0, 8)]);
-  }
-
-  void test_abstractClassMember_setter() {
-    createParser('abstract set m(v);');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.ABSTRACT_CLASS_MEMBER, 0, 8)]);
-  }
-
-  void test_abstractEnum() {
-    parseCompilationUnit("abstract enum E {ONE}",
-        errors: [expectedError(ParserErrorCode.ABSTRACT_ENUM, 0, 8)]);
-  }
-
-  void test_abstractTopLevelFunction_function() {
-    parseCompilationUnit("abstract f(v) {}", errors: [
-      expectedError(ParserErrorCode.ABSTRACT_TOP_LEVEL_FUNCTION, 0, 8)
-    ]);
-  }
-
-  void test_abstractTopLevelFunction_getter() {
-    parseCompilationUnit("abstract get m {}", errors: [
-      expectedError(ParserErrorCode.ABSTRACT_TOP_LEVEL_FUNCTION, 0, 8)
-    ]);
-  }
-
-  void test_abstractTopLevelFunction_setter() {
-    parseCompilationUnit("abstract set m(v) {}", errors: [
-      expectedError(ParserErrorCode.ABSTRACT_TOP_LEVEL_FUNCTION, 0, 8)
-    ]);
-  }
-
-  void test_abstractTopLevelVariable() {
-    parseCompilationUnit("abstract C f;", errors: [
-      expectedError(ParserErrorCode.ABSTRACT_TOP_LEVEL_VARIABLE, 0, 8)
-    ]);
-  }
-
-  void test_abstractTypeDef() {
-    parseCompilationUnit("abstract typedef F();",
-        errors: [expectedError(ParserErrorCode.ABSTRACT_TYPEDEF, 0, 8)]);
-  }
-
-  void test_await_missing_async2_issue36048() {
-    parseCompilationUnit('''
-main() { // missing async
-  await foo.bar();
-}
-''', errors: [
-      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 28, 5)
-    ]);
-  }
-
-  void test_await_missing_async3_issue36048() {
-    parseCompilationUnit('''
-main() { // missing async
-  (await foo);
-}
-''', errors: [
-      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 29, 5)
-    ]);
-  }
-
-  void test_await_missing_async4_issue36048() {
-    parseCompilationUnit('''
-main() { // missing async
-  [await foo];
-}
-''', errors: [
-      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 29, 5)
-    ]);
-  }
-
-  void test_await_missing_async_issue36048() {
-    parseCompilationUnit('''
-main() { // missing async
-  await foo();
-}
-''', errors: [
-      expectedError(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, 28, 5)
-    ]);
-  }
-
-  void test_breakOutsideOfLoop_breakInDoStatement() {
-    DoStatement statement = parseStatement('do {break;} while (x);');
-    expectNotNullIfNoErrors(statement);
-    assertNoErrors();
-  }
-
-  void test_breakOutsideOfLoop_breakInForStatement() {
-    Statement statement = parseStatement('for (; x;) {break;}');
-    expectNotNullIfNoErrors(statement);
-    assertNoErrors();
-  }
-
-  void test_breakOutsideOfLoop_breakInIfStatement() {
-    IfStatement statement = parseStatement('if (x) {break;}');
-    expectNotNullIfNoErrors(statement);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.BREAK_OUTSIDE_OF_LOOP, 8, 5)]);
-  }
-
-  void test_breakOutsideOfLoop_breakInSwitchStatement() {
-    SwitchStatement statement = parseStatement('switch (x) {case 1: break;}');
-    expectNotNullIfNoErrors(statement);
-    assertNoErrors();
-  }
-
-  void test_breakOutsideOfLoop_breakInWhileStatement() {
-    WhileStatement statement = parseStatement('while (x) {break;}');
-    expectNotNullIfNoErrors(statement);
-    assertNoErrors();
-  }
-
-  void test_breakOutsideOfLoop_functionExpression_inALoop() {
-    parseStatement("for(; x;) {() {break;};}");
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.BREAK_OUTSIDE_OF_LOOP, 15, 5)]);
-  }
-
-  void test_breakOutsideOfLoop_functionExpression_withALoop() {
-    parseStatement("() {for (; x;) {break;}};");
-  }
-
-  void test_classInClass_abstract() {
-    parseCompilationUnit("class C { abstract class B {} }", errors: [
-      expectedError(ParserErrorCode.ABSTRACT_CLASS_MEMBER, 10, 8),
-      expectedError(ParserErrorCode.CLASS_IN_CLASS, 19, 5)
-    ]);
-  }
-
-  void test_classInClass_nonAbstract() {
-    parseCompilationUnit("class C { class B {} }",
-        errors: [expectedError(ParserErrorCode.CLASS_IN_CLASS, 10, 5)]);
-  }
-
-  void test_classTypeAlias_abstractAfterEq() {
-    // This syntax has been removed from the language in favor of
-    // "abstract class A = B with C;" (issue 18098).
-    createParser('class A = abstract B with C;', expectedEndOffset: 21);
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([
-      expectedError(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE, 10, 8),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 19, 1),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 19, 1)
-    ]);
-  }
-
-  void test_colonInPlaceOfIn() {
-    parseStatement("for (var x : list) {}");
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.COLON_IN_PLACE_OF_IN, 11, 1)]);
-  }
-
-  void test_constAndCovariant() {
-    createParser('covariant const C f = null;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.CONFLICTING_MODIFIERS, 10, 5)]);
-  }
-
-  void test_constAndFinal() {
-    createParser('const final int x = null;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.CONST_AND_FINAL, 6, 5)]);
-  }
-
-  void test_constAndVar() {
-    createParser('const var x = null;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.CONFLICTING_MODIFIERS, 6, 3)]);
-  }
-
-  void test_constClass() {
-    parseCompilationUnit("const class C {}",
-        errors: [expectedError(ParserErrorCode.CONST_CLASS, 0, 5)]);
-  }
-
-  void test_constConstructorWithBody() {
-    createParser('const C() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.CONST_CONSTRUCTOR_WITH_BODY, 10, 1)]);
-  }
-
-  void test_constEnum() {
-    parseCompilationUnit("const enum E {ONE}", errors: [
-      // Fasta interprets the `const` as a malformed top level const
-      // and `enum` as the start of an enum declaration.
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 4),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 6, 4),
-    ]);
-  }
-
-  void test_constFactory() {
-    createParser('const factory C() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([expectedError(ParserErrorCode.CONST_FACTORY, 0, 5)]);
-  }
-
-  void test_constMethod() {
-    createParser('const int m() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([expectedError(ParserErrorCode.CONST_METHOD, 0, 5)]);
-  }
-
-  void test_constMethod_noReturnType() {
-    createParser('const m() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([expectedError(ParserErrorCode.CONST_METHOD, 0, 5)]);
-  }
-
-  void test_constMethod_noReturnType2() {
-    createParser('const m();');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([expectedError(ParserErrorCode.CONST_METHOD, 0, 5)]);
-  }
-
-  void test_constructor_super_cascade_synthetic() {
-    // https://github.com/dart-lang/sdk/issues/37110
-    parseCompilationUnit('class B extends A { B(): super.. {} }', errors: [
-      expectedError(ParserErrorCode.INVALID_SUPER_IN_INITIALIZER, 25, 5),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 30, 2),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 33, 1),
-    ]);
-  }
-
-  void test_constructor_super_field() {
-    // https://github.com/dart-lang/sdk/issues/36262
-    // https://github.com/dart-lang/sdk/issues/31198
-    parseCompilationUnit('class B extends A { B(): super().foo {} }', errors: [
-      expectedError(ParserErrorCode.INVALID_SUPER_IN_INITIALIZER, 25, 5),
-    ]);
-  }
-
-  void test_constructor_super_method() {
-    // https://github.com/dart-lang/sdk/issues/36262
-    // https://github.com/dart-lang/sdk/issues/31198
-    parseCompilationUnit('class B extends A { B(): super().foo() {} }',
-        errors: [
-          expectedError(ParserErrorCode.INVALID_SUPER_IN_INITIALIZER, 25, 5),
-        ]);
-  }
-
-  void test_constructor_super_named_method() {
-    // https://github.com/dart-lang/sdk/issues/37600
-    parseCompilationUnit('class B extends A { B(): super.c().create() {} }',
-        errors: [
-          expectedError(ParserErrorCode.INVALID_SUPER_IN_INITIALIZER, 25, 5),
-        ]);
-  }
-
-  void test_constructor_super_named_method_method() {
-    // https://github.com/dart-lang/sdk/issues/37600
-    parseCompilationUnit('class B extends A { B(): super.c().create().x() {} }',
-        errors: [
-          expectedError(ParserErrorCode.INVALID_SUPER_IN_INITIALIZER, 25, 5),
-        ]);
-  }
-
-  void test_constructor_this_cascade_synthetic() {
-    // https://github.com/dart-lang/sdk/issues/37110
-    parseCompilationUnit('class B extends A { B(): this.. {} }', errors: [
-      expectedError(ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 25, 4),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 29, 2),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 32, 1),
-    ]);
-  }
-
-  void test_constructor_this_field() {
-    // https://github.com/dart-lang/sdk/issues/36262
-    // https://github.com/dart-lang/sdk/issues/31198
-    parseCompilationUnit('class B extends A { B(): this().foo; }', errors: [
-      expectedError(ParserErrorCode.INVALID_THIS_IN_INITIALIZER, 25, 4),
-    ]);
-  }
-
-  void test_constructor_this_method() {
-    // https://github.com/dart-lang/sdk/issues/36262
-    // https://github.com/dart-lang/sdk/issues/31198
-    parseCompilationUnit('class B extends A { B(): this().foo(); }', errors: [
-      expectedError(ParserErrorCode.INVALID_THIS_IN_INITIALIZER, 25, 4),
-    ]);
-  }
-
-  void test_constructor_this_named_method() {
-    // https://github.com/dart-lang/sdk/issues/37600
-    parseCompilationUnit('class B extends A { B(): super.c().create() {} }',
-        errors: [
-          expectedError(ParserErrorCode.INVALID_SUPER_IN_INITIALIZER, 25, 5),
-        ]);
-  }
-
-  void test_constructor_this_named_method_field() {
-    // https://github.com/dart-lang/sdk/issues/37600
-    parseCompilationUnit('class B extends A { B(): super.c().create().x {} }',
-        errors: [
-          expectedError(ParserErrorCode.INVALID_SUPER_IN_INITIALIZER, 25, 5),
-        ]);
-  }
-
-  void test_constructorPartial() {
-    createParser('class C { C< }');
-    parser.parseCompilationUnit2();
-    listener.assertErrors([
-      expectedError(ParserErrorCode.TYPE_PARAMETER_ON_CONSTRUCTOR, 11, 2),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 13, 1),
-      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 10, 1),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 13, 1),
-    ]);
-  }
-
-  void test_constructorPartial2() {
-    createParser('class C { C<@Foo }');
-    parser.parseCompilationUnit2();
-    listener.assertErrors([
-      expectedError(ParserErrorCode.TYPE_PARAMETER_ON_CONSTRUCTOR, 11, 6),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 17, 1),
-      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 10, 1),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 17, 1)
-    ]);
-  }
-
-  void test_constructorPartial3() {
-    createParser('class C { C<@Foo @Bar() }');
-    parser.parseCompilationUnit2();
-    listener.assertErrors([
-      expectedError(ParserErrorCode.TYPE_PARAMETER_ON_CONSTRUCTOR, 11, 13),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 24, 1),
-      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 10, 1),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 24, 1)
-    ]);
-  }
-
-  void test_constructorWithReturnType() {
-    createParser('C C() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.CONSTRUCTOR_WITH_RETURN_TYPE, 0, 1),
-    ]);
-  }
-
-  void test_constructorWithReturnType_var() {
-    createParser('var C() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.VAR_RETURN_TYPE, 0, 3)]);
-  }
-
-  void test_constTypedef() {
-    parseCompilationUnit("const typedef F();", errors: [
-      // Fasta interprets the `const` as a malformed top level const
-      // and `typedef` as the start of an typedef declaration.
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 7),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 6, 7),
-    ]);
-  }
-
-  void test_continueOutsideOfLoop_continueInDoStatement() {
-    DoStatement statement = parseStatement('do {continue;} while (x);');
-    expectNotNullIfNoErrors(statement);
-    assertNoErrors();
-  }
-
-  void test_continueOutsideOfLoop_continueInForStatement() {
-    Statement statement = parseStatement('for (; x;) {continue;}');
-    expectNotNullIfNoErrors(statement);
-    assertNoErrors();
-  }
-
-  void test_continueOutsideOfLoop_continueInIfStatement() {
-    IfStatement statement = parseStatement('if (x) {continue;}');
-    expectNotNullIfNoErrors(statement);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.CONTINUE_OUTSIDE_OF_LOOP, 8, 8)]);
-  }
-
-  void test_continueOutsideOfLoop_continueInSwitchStatement() {
-    SwitchStatement statement =
-        parseStatement('switch (x) {case 1: continue a;}');
-    expectNotNullIfNoErrors(statement);
-    assertNoErrors();
-  }
-
-  void test_continueOutsideOfLoop_continueInWhileStatement() {
-    WhileStatement statement = parseStatement('while (x) {continue;}');
-    expectNotNullIfNoErrors(statement);
-    assertNoErrors();
-  }
-
-  void test_continueOutsideOfLoop_functionExpression_inALoop() {
-    parseStatement("for(; x;) {() {continue;};}");
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.CONTINUE_OUTSIDE_OF_LOOP, 15, 8)]);
-  }
-
-  void test_continueOutsideOfLoop_functionExpression_withALoop() {
-    parseStatement("() {for (; x;) {continue;}};");
-  }
-
-  void test_continueWithoutLabelInCase_error() {
-    SwitchStatement statement =
-        parseStatement('switch (x) {case 1: continue;}');
-    expectNotNullIfNoErrors(statement);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.CONTINUE_WITHOUT_LABEL_IN_CASE, 20, 8)]);
-  }
-
-  void test_continueWithoutLabelInCase_noError() {
-    SwitchStatement statement =
-        parseStatement('switch (x) {case 1: continue a;}');
-    expectNotNullIfNoErrors(statement);
-    assertNoErrors();
-  }
-
-  void test_continueWithoutLabelInCase_noError_switchInLoop() {
-    WhileStatement statement =
-        parseStatement('while (a) { switch (b) {default: continue;}}');
-    expectNotNullIfNoErrors(statement);
-    assertNoErrors();
-  }
-
-  void test_covariantAfterVar() {
-    createParser('var covariant f;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 4, 9)]);
-  }
-
-  void test_covariantAndFinal() {
-    createParser('covariant final f = null;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrorsWithCodes([ParserErrorCode.FINAL_AND_COVARIANT]);
-  }
-
-  void test_covariantAndStatic() {
-    createParser('covariant static A f;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.COVARIANT_AND_STATIC, 10, 6)]);
-  }
-
-  void test_covariantAndType_local() {
-    // This is currently reporting EXPECTED_TOKEN for a missing semicolon, but
-    // this would be a better error message.
-    parseStatement("covariant int x;");
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.EXTRANEOUS_MODIFIER, 0, 9)]);
-  }
-
-  void test_covariantConstructor() {
-    createParser('class C { covariant C(); }');
-    ClassDeclaration member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.COVARIANT_MEMBER, 10, 9)]);
-  }
-
-  void test_covariantMember_getter_noReturnType() {
-    createParser('static covariant get x => 0;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.COVARIANT_AND_STATIC, 7, 9)]);
-  }
-
-  void test_covariantMember_getter_returnType() {
-    createParser('static covariant int get x => 0;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.COVARIANT_AND_STATIC, 7, 9)]);
-  }
-
-  void test_covariantMember_method() {
-    createParser('covariant int m() => 0;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.COVARIANT_MEMBER, 0, 9)]);
-  }
-
-  void test_covariantTopLevelDeclaration_class() {
-    createParser('covariant class C {}');
-    ClassDeclaration member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.COVARIANT_TOP_LEVEL_DECLARATION, 0, 9)]);
-  }
-
-  void test_covariantTopLevelDeclaration_enum() {
-    createParser('covariant enum E { v }');
-    EnumDeclaration member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.COVARIANT_TOP_LEVEL_DECLARATION, 0, 9)]);
-  }
-
-  void test_covariantTopLevelDeclaration_typedef() {
-    parseCompilationUnit("covariant typedef F();", errors: [
-      expectedError(ParserErrorCode.COVARIANT_TOP_LEVEL_DECLARATION, 0, 9)
-    ]);
-  }
-
-  void test_defaultValueInFunctionType_named_colon() {
-    createParser('({int x : 0})');
-    FormalParameter parameter =
-        parser.parseFormalParameterList(inFunctionType: true).parameters[0];
-    expectNotNullIfNoErrors(parameter);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE, 8, 1)]);
-  }
-
-  void test_defaultValueInFunctionType_named_equal() {
-    createParser('({int x = 0})');
-    FormalParameter parameter =
-        parser.parseFormalParameterList(inFunctionType: true).parameters[0];
-    expectNotNullIfNoErrors(parameter);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE, 8, 1)]);
-  }
-
-  void test_defaultValueInFunctionType_positional() {
-    createParser('([int x = 0])');
-    FormalParameter parameter =
-        parser.parseFormalParameterList(inFunctionType: true).parameters[0];
-    expectNotNullIfNoErrors(parameter);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE, 8, 1)]);
-  }
-
-  void test_directiveAfterDeclaration_classBeforeDirective() {
-    // TODO(brianwilkerson) Remove codes when highlighting is fixed.
-    CompilationUnit unit = parseCompilationUnit("class Foo{} library l;",
-        codes: [
-          ParserErrorCode.LIBRARY_DIRECTIVE_NOT_FIRST
-        ],
-        errors: [
-          expectedError(ParserErrorCode.LIBRARY_DIRECTIVE_NOT_FIRST, 12, 10)
-        ]);
-    expect(unit, isNotNull);
-  }
-
-  void test_directiveAfterDeclaration_classBetweenDirectives() {
-    // TODO(brianwilkerson) Remove codes when highlighting is fixed.
-    CompilationUnit unit =
-        parseCompilationUnit("library l;\nclass Foo{}\npart 'a.dart';", codes: [
-      ParserErrorCode.DIRECTIVE_AFTER_DECLARATION
-    ], errors: [
-      expectedError(ParserErrorCode.DIRECTIVE_AFTER_DECLARATION, 23, 14)
-    ]);
-    expect(unit, isNotNull);
-  }
-
-  void test_duplicatedModifier_const() {
-    createParser('const const m = null;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.DUPLICATED_MODIFIER, 6, 5)]);
-  }
-
-  void test_duplicatedModifier_external() {
-    createParser('external external f();');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.DUPLICATED_MODIFIER, 9, 8)]);
-  }
-
-  void test_duplicatedModifier_factory() {
-    createParser('factory factory C() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.DUPLICATED_MODIFIER, 8, 7)]);
-  }
-
-  void test_duplicatedModifier_final() {
-    createParser('final final m = null;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.DUPLICATED_MODIFIER, 6, 5)]);
-  }
-
-  void test_duplicatedModifier_static() {
-    createParser('static static var m;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.DUPLICATED_MODIFIER, 7, 6)]);
-  }
-
-  void test_duplicatedModifier_var() {
-    createParser('var var m;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.DUPLICATED_MODIFIER, 4, 3)]);
-  }
-
-  void test_duplicateLabelInSwitchStatement() {
-    SwitchStatement statement =
-        parseStatement('switch (e) {l1: case 0: break; l1: case 1: break;}');
-    expectNotNullIfNoErrors(statement);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.DUPLICATE_LABEL_IN_SWITCH_STATEMENT, 31, 2)
-    ]);
-  }
-
-  void test_emptyEnumBody() {
-    createParser('enum E {}');
-    EnumDeclaration declaration = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(declaration);
-    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
-    listener.assertErrorsWithCodes([ParserErrorCode.EMPTY_ENUM_BODY]);
-//    listener
-//        .assertErrors([expectedError(ParserErrorCode.EMPTY_ENUM_BODY, 7, 2),]);
-  }
-
-  void test_enumInClass() {
-    parseCompilationUnit(r'''
-class Foo {
-  enum Bar {
-    Bar1, Bar2, Bar3
-  }
-}
-''', errors: [expectedError(ParserErrorCode.ENUM_IN_CLASS, 14, 4)]);
-  }
-
-  void test_equalityCannotBeEqualityOperand_eq_eq() {
-    parseExpression("1 == 2 == 3", errors: [
-      expectedError(ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND, 7, 2)
-    ]);
-  }
-
-  void test_equalityCannotBeEqualityOperand_eq_neq() {
-    parseExpression("1 == 2 != 3", errors: [
-      expectedError(ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND, 7, 2)
-    ]);
-  }
-
-  void test_equalityCannotBeEqualityOperand_neq_eq() {
-    parseExpression("1 != 2 == 3", errors: [
-      expectedError(ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND, 7, 2)
-    ]);
-  }
-
-  void test_expectedBody_class() {
-    parseCompilationUnit("class A class B {}",
-        errors: [expectedError(ParserErrorCode.EXPECTED_BODY, 6, 1)]);
-  }
-
-  void test_expectedCaseOrDefault() {
-    SwitchStatement statement = parseStatement('switch (e) {break;}');
-    expectNotNullIfNoErrors(statement);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 12, 5)]);
-  }
-
-  void test_expectedClassMember_inClass_afterType() {
-    parseCompilationUnit('class C{ heart 2 heart }', errors: [
-      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 9, 5),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 9, 5),
-      expectedError(ParserErrorCode.EXPECTED_CLASS_MEMBER, 15, 1),
-      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 17, 5),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 17, 5)
-    ]);
-  }
-
-  void test_expectedClassMember_inClass_beforeType() {
-    parseCompilationUnit('class C { 4 score }', errors: [
-      expectedError(ParserErrorCode.EXPECTED_CLASS_MEMBER, 10, 1),
-      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 12, 5),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 12, 5)
-    ]);
-  }
-
-  void test_expectedExecutable_afterAnnotation_atEOF() {
-    // TODO(brianwilkerson) Remove codes when highlighting is fixed.
-    parseCompilationUnit('@A',
-        codes: [ParserErrorCode.EXPECTED_EXECUTABLE],
-        errors: [expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 1, 1)]);
-  }
-
-  void test_expectedExecutable_inClass_afterVoid() {
-    parseCompilationUnit('class C { void 2 void }', errors: [
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 15, 1),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 17, 4),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 22, 1),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 22, 1)
-    ]);
-  }
-
-  void test_expectedExecutable_topLevel_afterType() {
-    CompilationUnit unit = parseCompilationUnit('heart 2 heart', errors: [
-      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 0, 5),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 0, 5),
-      expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 6, 1),
-      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 8, 5),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 8, 5),
-    ]);
-    expect(unit, isNotNull);
-  }
-
-  void test_expectedExecutable_topLevel_afterVoid() {
-    CompilationUnit unit = parseCompilationUnit('void 2 void', errors: [
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 5, 1),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 5, 1),
-      expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 5, 1),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 11, 0),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 11, 0),
-    ]);
-    expect(unit, isNotNull);
-  }
-
-  void test_expectedExecutable_topLevel_beforeType() {
-    parseCompilationUnit('4 score', errors: [
-      expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 0, 1),
-      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 2, 5),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 2, 5),
-    ]);
-  }
-
-  void test_expectedExecutable_topLevel_eof() {
-    parseCompilationUnit('x', errors: [
-      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 0, 1),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 0, 1)
-    ]);
-  }
-
-  void test_expectedInterpolationIdentifier() {
-    StringLiteral literal = parseExpression("'\$x\$'",
-        errors: [expectedError(ScannerErrorCode.MISSING_IDENTIFIER, 4, 1)]);
-    expectNotNullIfNoErrors(literal);
-  }
-
-  void test_expectedInterpolationIdentifier_emptyString() {
-    // The scanner inserts an empty string token between the two $'s; we need to
-    // make sure that the MISSING_IDENTIFIER error that is generated has a
-    // nonzero width so that it will show up in the editor UI.
-    StringLiteral literal = parseExpression("'\$\$foo'",
-        errors: [expectedError(ScannerErrorCode.MISSING_IDENTIFIER, 2, 1)]);
-    expectNotNullIfNoErrors(literal);
-  }
-
-  void test_expectedToken_commaMissingInArgumentList() {
-    createParser('(x, y z)');
-    ArgumentList list = parser.parseArgumentList();
-    expectNotNullIfNoErrors(list);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 6, 1)]);
-  }
-
-  void test_expectedToken_parseStatement_afterVoid() {
-    parseStatement("void}", expectedEndOffset: 4);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 4, 1),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 4, 1)
-    ]);
-  }
-
-  void test_expectedToken_semicolonMissingAfterExport() {
-    // TODO(brianwilkerson) Remove codes when highlighting is fixed.
-    CompilationUnit unit = parseCompilationUnit("export '' class A {}",
-        codes: [ParserErrorCode.EXPECTED_TOKEN],
-        errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 2)]);
-    ExportDirective directive = unit.directives[0] as ExportDirective;
-    expect(directive.uri, isNotNull);
-    expect(directive.uri.stringValue, '');
-    expect(directive.uri.beginToken.isSynthetic, false);
-    expect(directive.uri.isSynthetic, false);
-    Token semicolon = directive.semicolon;
-    expect(semicolon, isNotNull);
-    expect(semicolon.isSynthetic, isTrue);
-    ClassDeclaration clazz = unit.declarations[0] as ClassDeclaration;
-    expect(clazz.name.name, 'A');
-  }
-
-  void test_expectedToken_semicolonMissingAfterExpression() {
-    parseStatement("x");
-    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
-    listener.assertErrorsWithCodes([ParserErrorCode.EXPECTED_TOKEN]);
-//    listener
-//        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 0, 1)]);
-  }
-
-  void test_expectedToken_semicolonMissingAfterImport() {
-    // TODO(brianwilkerson) Remove codes when highlighting is fixed.
-    CompilationUnit unit = parseCompilationUnit("import '' class A {}",
-        codes: [ParserErrorCode.EXPECTED_TOKEN],
-        errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 2)]);
-    ImportDirective directive = unit.directives[0] as ImportDirective;
-    Token semicolon = directive.semicolon;
-    expect(semicolon, isNotNull);
-    expect(semicolon.isSynthetic, isTrue);
-  }
-
-  void test_expectedToken_uriAndSemicolonMissingAfterExport() {
-    CompilationUnit unit = parseCompilationUnit("export class A {}", errors: [
-      expectedError(ParserErrorCode.EXPECTED_STRING_LITERAL, 7, 5),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 5),
-    ]);
-    ExportDirective directive = unit.directives[0] as ExportDirective;
-    expect(directive.uri, isNotNull);
-    expect(directive.uri.stringValue, '');
-    expect(directive.uri.beginToken.isSynthetic, true);
-    expect(directive.uri.isSynthetic, true);
-    Token semicolon = directive.semicolon;
-    expect(semicolon, isNotNull);
-    expect(semicolon.isSynthetic, isTrue);
-    ClassDeclaration clazz = unit.declarations[0] as ClassDeclaration;
-    expect(clazz.name.name, 'A');
-  }
-
-  void test_expectedToken_whileMissingInDoStatement() {
-    parseStatement("do {} (x);");
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 6, 1)]);
-  }
-
-  void test_expectedTypeName_as() {
-    parseExpression("x as",
-        errors: [expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 4, 0)]);
-  }
-
-  void test_expectedTypeName_as_void() {
-    parseExpression("x as void)",
-        expectedEndOffset: 9,
-        errors: [expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 5, 4)]);
-  }
-
-  void test_expectedTypeName_is() {
-    parseExpression("x is",
-        errors: [expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 4, 0)]);
-  }
-
-  void test_expectedTypeName_is_void() {
-    parseExpression("x is void)",
-        expectedEndOffset: 9,
-        errors: [expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 5, 4)]);
-  }
-
-  void test_exportAsType() {
-    parseCompilationUnit('export<dynamic> foo;', errors: [
-      expectedError(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE, 0, 6)
-    ]);
-  }
-
-  void test_exportAsType_inClass() {
-    parseCompilationUnit('class C { export<dynamic> foo; }', errors: [
-      expectedError(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE, 10, 6)
-    ]);
-  }
-
-  void test_exportDirectiveAfterPartDirective() {
-    parseCompilationUnit("part 'a.dart'; export 'b.dart';", errors: [
-      expectedError(
-          ParserErrorCode.EXPORT_DIRECTIVE_AFTER_PART_DIRECTIVE, 15, 6)
-    ]);
-  }
-
-  void test_externalAfterConst() {
-    createParser('const external C();');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 6, 8)]);
-  }
-
-  void test_externalAfterFactory() {
-    createParser('factory external C();');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 8, 8)]);
-  }
-
-  void test_externalAfterStatic() {
-    createParser('static external int m();');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 7, 8)]);
-  }
-
-  void test_externalClass() {
-    parseCompilationUnit("external class C {}",
-        errors: [expectedError(ParserErrorCode.EXTERNAL_CLASS, 0, 8)]);
-  }
-
-  void test_externalConstructorWithBody_factory() {
-    createParser('external factory C() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.EXTERNAL_FACTORY_WITH_BODY, 21, 1)]);
-  }
-
-  void test_externalConstructorWithBody_named() {
-    createParser('external C.c() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
-    listener.assertErrorsWithCodes([ParserErrorCode.EXTERNAL_METHOD_WITH_BODY]);
-//      listener.assertErrors(
-//          [expectedError(ParserErrorCode.EXTERNAL_METHOD_WITH_BODY, 15, 2)]);
-  }
-
-  void test_externalEnum() {
-    parseCompilationUnit("external enum E {ONE}",
-        errors: [expectedError(ParserErrorCode.EXTERNAL_ENUM, 0, 8)]);
-  }
-
-  void test_externalField_const() {
-    createParser('external const A f;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(CompileTimeErrorCode.CONST_NOT_INITIALIZED, 17, 1)]);
-  }
-
-  void test_externalField_final() {
-    createParser('external final A f;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    assertNoErrors();
-  }
-
-  void test_externalField_static() {
-    createParser('external static A f;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    assertNoErrors();
-  }
-
-  void test_externalField_typed() {
-    createParser('external A f;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    assertNoErrors();
-  }
-
-  void test_externalField_untyped() {
-    createParser('external var f;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    assertNoErrors();
-  }
-
-  void test_externalGetterWithBody() {
-    createParser('external int get x {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
-    listener.assertErrorsWithCodes([ParserErrorCode.EXTERNAL_METHOD_WITH_BODY]);
-//      listener.assertErrors(
-//          [expectedError(ParserErrorCode.EXTERNAL_METHOD_WITH_BODY, 19, 2)]);
-  }
-
-  void test_externalMethodWithBody() {
-    createParser('external m() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
-    listener.assertErrorsWithCodes([ParserErrorCode.EXTERNAL_METHOD_WITH_BODY]);
-//    listener.assertErrors(
-//        [expectedError(ParserErrorCode.EXTERNAL_METHOD_WITH_BODY, 13, 2)]);
-  }
-
-  void test_externalOperatorWithBody() {
-    createParser('external operator +(int value) {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
-    listener.assertErrorsWithCodes([ParserErrorCode.EXTERNAL_METHOD_WITH_BODY]);
-//      listener.assertErrors(
-//          [expectedError(ParserErrorCode.EXTERNAL_METHOD_WITH_BODY, 31, 2)]);
-  }
-
-  void test_externalSetterWithBody() {
-    createParser('external set x(int value) {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
-    listener.assertErrorsWithCodes([ParserErrorCode.EXTERNAL_METHOD_WITH_BODY]);
-//      listener.assertErrors(
-//          [expectedError(ParserErrorCode.EXTERNAL_METHOD_WITH_BODY, 26, 2)]);
-  }
-
-  void test_externalTypedef() {
-    parseCompilationUnit("external typedef F();",
-        errors: [expectedError(ParserErrorCode.EXTERNAL_TYPEDEF, 0, 8)]);
-  }
-
-  void test_extraCommaInParameterList() {
-    createParser('(int a, , int b)');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 1)]);
-  }
-
-  void test_extraCommaTrailingNamedParameterGroup() {
-    createParser('({int b},)');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 8, 1)]);
-  }
-
-  void test_extraCommaTrailingPositionalParameterGroup() {
-    createParser('([int b],)');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 8, 1)]);
-  }
-
-  void test_extraTrailingCommaInParameterList() {
-    createParser('(a,,)');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 3, 1)]);
-  }
-
-  void test_factory_issue_36400() {
-    parseCompilationUnit('class T { T factory T() { return null; } }',
-        errors: [expectedError(ParserErrorCode.TYPE_BEFORE_FACTORY, 10, 1)]);
-  }
-
-  void test_factoryTopLevelDeclaration_class() {
-    parseCompilationUnit("factory class C {}", errors: [
-      expectedError(ParserErrorCode.FACTORY_TOP_LEVEL_DECLARATION, 0, 7)
-    ]);
-  }
-
-  void test_factoryTopLevelDeclaration_enum() {
-    parseCompilationUnit("factory enum E { v }", errors: [
-      expectedError(ParserErrorCode.FACTORY_TOP_LEVEL_DECLARATION, 0, 7)
-    ]);
-  }
-
-  void test_factoryTopLevelDeclaration_typedef() {
-    parseCompilationUnit("factory typedef F();", errors: [
-      expectedError(ParserErrorCode.FACTORY_TOP_LEVEL_DECLARATION, 0, 7)
-    ]);
-  }
-
-  void test_factoryWithInitializers() {
-    createParser('factory C() : x = 3 {}', expectedEndOffset: 12);
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 12, 1)]);
-  }
-
-  void test_factoryWithoutBody() {
-    createParser('factory C();');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 11, 1)]);
-  }
-
-  void test_fieldInitializerOutsideConstructor() {
-    createParser('void m(this.x);');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR, 7, 4)
-    ]);
-  }
-
-  void test_finalAndCovariant() {
-    createParser('final covariant f = null;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 6, 9),
-      expectedError(ParserErrorCode.FINAL_AND_COVARIANT, 6, 9)
-    ]);
-  }
-
-  void test_finalAndVar() {
-    createParser('final var x = null;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([expectedError(ParserErrorCode.FINAL_AND_VAR, 6, 3)]);
-  }
-
-  void test_finalClass() {
-    parseCompilationUnit("final class C {}",
-        errors: [expectedError(ParserErrorCode.FINAL_CLASS, 0, 5)]);
-  }
-
-  void test_finalClassMember_modifierOnly() {
-    createParser('final');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 5, 0),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 5, 0)
-    ]);
-  }
-
-  void test_finalConstructor() {
-    createParser('final C() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.EXTRANEOUS_MODIFIER, 0, 5)]);
-  }
-
-  void test_finalEnum() {
-    parseCompilationUnit("final enum E {ONE}", errors: [
-      // Fasta interprets the `final` as a malformed top level final
-      // and `enum` as the start of a enum declaration.
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 4),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 6, 4),
-    ]);
-  }
-
-  void test_finalMethod() {
-    createParser('final int m() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.EXTRANEOUS_MODIFIER, 0, 5)]);
-  }
-
-  void test_finalTypedef() {
-    parseCompilationUnit("final typedef F();", errors: [
-      // Fasta interprets the `final` as a malformed top level final
-      // and `typedef` as the start of an typedef declaration.
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 7),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 6, 7),
-    ]);
-  }
-
-  void test_functionTypedField_invalidType_abstract() {
-    parseCompilationUnit("Function(abstract) x = null;", errors: [
-      expectedError(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE, 9, 8)
-    ]);
-  }
-
-  void test_functionTypedField_invalidType_class() {
-    parseCompilationUnit("Function(class) x = null;", errors: [
-      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 9, 5),
-      expectedError(ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD, 9, 5)
-    ]);
-  }
-
-  void test_functionTypedParameter_const() {
-    parseCompilationUnit("void f(const x()) {}", errors: [
-      expectedError(ParserErrorCode.EXTRANEOUS_MODIFIER, 7, 5),
-      expectedError(ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR, 7, 5)
-    ]);
-  }
-
-  void test_functionTypedParameter_final() {
-    parseCompilationUnit("void f(final x()) {}", errors: [
-      expectedError(ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR, 7, 5)
-    ]);
-  }
-
-  void test_functionTypedParameter_incomplete1() {
-    parseCompilationUnit("void f(int Function(", errors: [
-      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 20, 1),
-      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 20, 1),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 20, 0),
-    ]);
-  }
-
-  void test_functionTypedParameter_var() {
-    parseCompilationUnit("void f(var x()) {}", errors: [
-      expectedError(ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR, 7, 3)
-    ]);
-  }
-
-  void test_genericFunctionType_asIdentifier() {
-    createParser('final int Function = 0;');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    listener.assertErrors([]);
-  }
-
-  void test_genericFunctionType_asIdentifier2() {
-    createParser('int Function() {}');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    listener.assertErrors([]);
-  }
-
-  void test_genericFunctionType_asIdentifier3() {
-    createParser('int Function() => 0;');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    listener.assertErrors([]);
-  }
-
-  void test_genericFunctionType_extraLessThan() {
-    createParser('''
-class Wrong<T> {
-  T Function(<List<int> foo) bar;
-}''');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 30, 1),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 30, 1)
-    ]);
-  }
-
-  void test_getterInFunction_block_noReturnType() {
-    Statement result =
-        parseStatement("get x { return _x; }", expectedEndOffset: 4);
-    // Fasta considers `get` to be an identifier in this situation.
-    // TODO(danrubel): Investigate better recovery.
-    ExpressionStatement statement = result;
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 0, 3)]);
-    expect(statement.expression.toSource(), 'get');
-  }
-
-  void test_getterInFunction_block_returnType() {
-    // Fasta considers `get` to be an identifier in this situation.
-    parseStatement("int get x { return _x; }", expectedEndOffset: 8);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 4, 3)]);
-  }
-
-  void test_getterInFunction_expression_noReturnType() {
-    // Fasta considers `get` to be an identifier in this situation.
-    parseStatement("get x => _x;", expectedEndOffset: 4);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 0, 3)]);
-  }
-
-  void test_getterInFunction_expression_returnType() {
-    // Fasta considers `get` to be an identifier in this situation.
-    parseStatement("int get x => _x;", expectedEndOffset: 8);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 4, 3)]);
-  }
-
-  void test_getterNativeWithBody() {
-    createParser('String get m native "str" => 0;');
-    parser.parseClassMember('C') as MethodDeclaration;
-    if (!allowNativeClause) {
-      assertErrorsWithCodes([
-        ParserErrorCode.NATIVE_CLAUSE_SHOULD_BE_ANNOTATION,
-        ParserErrorCode.EXTERNAL_METHOD_WITH_BODY,
-      ]);
-    } else {
-      assertErrorsWithCodes([
-        ParserErrorCode.EXTERNAL_METHOD_WITH_BODY,
-      ]);
-    }
-  }
-
-  void test_getterWithParameters() {
-    createParser('int get x() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
-    listener.assertErrorsWithCodes([ParserErrorCode.GETTER_WITH_PARAMETERS]);
-//    listener.assertErrors(
-//        [expectedError(ParserErrorCode.GETTER_WITH_PARAMETERS, 9, 2)]);
-  }
-
-  void test_illegalAssignmentToNonAssignable_assign_int() {
-    parseStatement("0 = 1;");
-    listener.assertErrors([
-      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 0, 1),
-      expectedError(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 0, 1),
-    ]);
-  }
-
-  void test_illegalAssignmentToNonAssignable_assign_this() {
-    parseStatement("this = 1;");
-    listener.assertErrors([
-      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 0, 4),
-      expectedError(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 0, 4)
-    ]);
-  }
-
-  void test_illegalAssignmentToNonAssignable_postfix_minusMinus_literal() {
-    parseExpression("0--", errors: [
-      expectedError(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 1, 2)
-    ]);
-  }
-
-  void test_illegalAssignmentToNonAssignable_postfix_plusPlus_literal() {
-    parseExpression("0++", errors: [
-      expectedError(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 1, 2)
-    ]);
-  }
-
-  void test_illegalAssignmentToNonAssignable_postfix_plusPlus_parenthesized() {
-    parseExpression("(x)++", errors: [
-      expectedError(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 3, 2)
-    ]);
-  }
-
-  void test_illegalAssignmentToNonAssignable_primarySelectorPostfix() {
-    parseExpression("x(y)(z)++", errors: [
-      expectedError(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 7, 2)
-    ]);
-  }
-
-  void test_illegalAssignmentToNonAssignable_superAssigned() {
-    parseStatement("super = x;");
-    listener.assertErrors([
-      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 0, 5),
-      expectedError(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 0, 5)
-    ]);
-  }
-
-  void test_implementsBeforeExtends() {
-    parseCompilationUnit("class A implements B extends C {}", errors: [
-      expectedError(ParserErrorCode.IMPLEMENTS_BEFORE_EXTENDS, 21, 7)
-    ]);
-  }
-
-  void test_implementsBeforeWith() {
-    parseCompilationUnit("class A extends B implements C with D {}",
-        errors: [expectedError(ParserErrorCode.IMPLEMENTS_BEFORE_WITH, 31, 4)]);
-  }
-
-  void test_importDirectiveAfterPartDirective() {
-    parseCompilationUnit("part 'a.dart'; import 'b.dart';", errors: [
-      expectedError(
-          ParserErrorCode.IMPORT_DIRECTIVE_AFTER_PART_DIRECTIVE, 15, 6)
-    ]);
-  }
-
-  void test_initializedVariableInForEach() {
-    Statement statement = parseStatement('for (int a = 0 in foo) {}');
-    expectNotNullIfNoErrors(statement);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.INITIALIZED_VARIABLE_IN_FOR_EACH, 11, 1)
-    ]);
-  }
-
-  void test_initializedVariableInForEach_annotation() {
-    Statement statement = parseStatement('for (@Foo var a = 0 in foo) {}');
-    expectNotNullIfNoErrors(statement);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.INITIALIZED_VARIABLE_IN_FOR_EACH, 16, 1)
-    ]);
-  }
-
-  void test_initializedVariableInForEach_localFunction() {
-    Statement statement = parseStatement('for (f()) {}');
-    expectNotNullIfNoErrors(statement);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 1),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 8, 1)
-    ]);
-  }
-
-  void test_initializedVariableInForEach_localFunction2() {
-    Statement statement = parseStatement('for (T f()) {}');
-    expectNotNullIfNoErrors(statement);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 9, 1),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 9, 1)
-    ]);
-  }
-
-  void test_initializedVariableInForEach_var() {
-    Statement statement = parseStatement('for (var a = 0 in foo) {}');
-    expectNotNullIfNoErrors(statement);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.INITIALIZED_VARIABLE_IN_FOR_EACH, 11, 1)
-    ]);
-  }
-
-  void test_invalidAwaitInFor() {
-    Statement statement = parseStatement('await for (; ;) {}');
-    expectNotNullIfNoErrors(statement);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.INVALID_AWAIT_IN_FOR, 0, 5)]);
-  }
-
-  void test_invalidCodePoint() {
-    StringLiteral literal = parseExpression("'begin \\u{110000}'",
-        errors: [expectedError(ParserErrorCode.INVALID_CODE_POINT, 7, 9)]);
-    expectNotNullIfNoErrors(literal);
-  }
-
-  @failingTest
-  void test_invalidCommentReference__new_nonIdentifier() {
-    // This test fails because the method parseCommentReference returns null.
-    createParser('');
-    CommentReference reference = parseCommentReference('new 42', 0);
-    expectNotNullIfNoErrors(reference);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.INVALID_COMMENT_REFERENCE, 0, 6)]);
-  }
-
-  @failingTest
-  void test_invalidCommentReference__new_tooMuch() {
-    createParser('');
-    CommentReference reference = parseCommentReference('new a.b.c.d', 0);
-    expectNotNullIfNoErrors(reference);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.INVALID_COMMENT_REFERENCE, 0, 11)]);
-  }
-
-  @failingTest
-  void test_invalidCommentReference__nonNew_nonIdentifier() {
-    // This test fails because the method parseCommentReference returns null.
-    createParser('');
-    CommentReference reference = parseCommentReference('42', 0);
-    expectNotNullIfNoErrors(reference);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.INVALID_COMMENT_REFERENCE, 0, 2)]);
-  }
-
-  @failingTest
-  void test_invalidCommentReference__nonNew_tooMuch() {
-    createParser('');
-    CommentReference reference = parseCommentReference('a.b.c.d', 0);
-    expectNotNullIfNoErrors(reference);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.INVALID_COMMENT_REFERENCE, 0, 7)]);
-  }
-
-  void test_invalidConstructorName_star() {
-    createParser("C.*();");
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 2, 1)]);
-  }
-
-  void test_invalidConstructorName_with() {
-    createParser("C.with();");
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD, 2, 4)
-    ]);
-  }
-
-  void test_invalidConstructorSuperAssignment() {
-    createParser("C() : super = 42;");
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 6, 5)]);
-  }
-
-  void test_invalidConstructorSuperFieldAssignment() {
-    createParser("C() : super.a = 42;");
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([
-      expectedError(
-          ParserErrorCode.FIELD_INITIALIZED_OUTSIDE_DECLARING_CLASS, 12, 1)
-    ]);
-  }
-
-  void test_invalidHexEscape_invalidDigit() {
-    StringLiteral literal = parseExpression("'not \\x0 a'",
-        errors: [expectedError(ParserErrorCode.INVALID_HEX_ESCAPE, 5, 3)]);
-    expectNotNullIfNoErrors(literal);
-  }
-
-  void test_invalidHexEscape_tooFewDigits() {
-    StringLiteral literal = parseExpression("'\\x0'",
-        errors: [expectedError(ParserErrorCode.INVALID_HEX_ESCAPE, 1, 3)]);
-    expectNotNullIfNoErrors(literal);
-  }
-
-  void test_invalidInlineFunctionType() {
-    parseCompilationUnit(
-      'typedef F = int Function(int a());',
-      errors: [
-        expectedError(CompileTimeErrorCode.INVALID_INLINE_FUNCTION_TYPE, 30, 1)
-      ],
-    );
-  }
-
-  void test_invalidInterpolation_missingClosingBrace_issue35900() {
-    parseCompilationUnit(r"main () { print('${x' '); }", errors: [
-      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 23, 1),
-      expectedError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 26, 1),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 20, 3),
-      expectedError(ParserErrorCode.EXPECTED_STRING_LITERAL, 23, 1),
-      expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 27, 0),
-    ]);
-  }
-
-  void test_invalidInterpolationIdentifier_startWithDigit() {
-    StringLiteral literal = parseExpression("'\$1'",
-        errors: [expectedError(ScannerErrorCode.MISSING_IDENTIFIER, 2, 1)]);
-    expectNotNullIfNoErrors(literal);
-  }
-
-  void test_invalidLiteralInConfiguration() {
-    createParser("if (a == 'x \$y z') 'a.dart'");
-    Configuration configuration = parser.parseConfiguration();
-    expectNotNullIfNoErrors(configuration);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.INVALID_LITERAL_IN_CONFIGURATION, 12, 2)
-    ]);
-  }
-
-  void test_invalidOperator() {
-    CompilationUnit unit = parseCompilationUnit(
-        'class C { void operator ===(x) { } }',
-        errors: [expectedError(ScannerErrorCode.UNSUPPORTED_OPERATOR, 24, 1)]);
-    expect(unit, isNotNull);
-  }
-
-  void test_invalidOperator_unary() {
-    createParser('class C { int operator unary- => 0; }');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 23, 5),
-      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 28, 1)
-    ]);
-  }
-
-  void test_invalidOperatorAfterSuper_assignableExpression() {
-    Expression expression = parseAssignableExpression('super?.v', false);
-    expectNotNullIfNoErrors(expression);
-    listener.assertErrors([
-      expectedError(
-          ParserErrorCode.INVALID_OPERATOR_QUESTIONMARK_PERIOD_FOR_SUPER, 5, 2)
-    ]);
-  }
-
-  void test_invalidOperatorAfterSuper_constructorInitializer2() {
-    parseCompilationUnit('class C { C() : super?.namedConstructor(); }',
-        errors: [
-          expectedError(
-              ParserErrorCode.INVALID_OPERATOR_QUESTIONMARK_PERIOD_FOR_SUPER,
-              21,
-              2)
-        ]);
-  }
-
-  void test_invalidOperatorAfterSuper_primaryExpression() {
-    Expression expression = parseExpression('super?.v', errors: [
-      expectedError(
-          ParserErrorCode.INVALID_OPERATOR_QUESTIONMARK_PERIOD_FOR_SUPER, 5, 2)
-    ]);
-    expectNotNullIfNoErrors(expression);
-  }
-
-  void test_invalidOperatorForSuper() {
-    createParser('++super');
-    Expression expression = parser.parseUnaryExpression();
-    expectNotNullIfNoErrors(expression);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 2, 5)]);
-  }
-
-  void test_invalidPropertyAccess_this() {
-    parseExpression('x.this',
-        errors: [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 2, 4)]);
-  }
-
-  void test_invalidStarAfterAsync() {
-    createParser('foo() async* => 0;');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    listener.assertErrors(
-        [expectedError(CompileTimeErrorCode.RETURN_IN_GENERATOR, 13, 2)]);
-  }
-
-  void test_invalidSync() {
-    createParser('foo() sync* => 0;');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    listener.assertErrors(
-        [expectedError(CompileTimeErrorCode.RETURN_IN_GENERATOR, 12, 2)]);
-  }
-
-  void test_invalidTopLevelSetter() {
-    parseCompilationUnit("var set foo; main(){}", errors: [
-      expectedError(ParserErrorCode.VAR_RETURN_TYPE, 0, 3),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 8, 3),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 11, 1)
-    ]);
-  }
-
-  void test_invalidTopLevelVar() {
-    parseCompilationUnit("var Function(var arg);", errors: [
-      expectedError(ParserErrorCode.VAR_RETURN_TYPE, 0, 3),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 21, 1),
-    ]);
-  }
-
-  void test_invalidTypedef() {
-    parseCompilationUnit("typedef var Function(var arg);", errors: [
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 3),
-      expectedError(ParserErrorCode.MISSING_TYPEDEF_PARAMETERS, 8, 3),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 8, 3),
-      expectedError(ParserErrorCode.VAR_RETURN_TYPE, 8, 3),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 29, 1),
-    ]);
-  }
-
-  void test_invalidTypedef2() {
-    // https://github.com/dart-lang/sdk/issues/31171
-    parseCompilationUnit(
-        "typedef T = typedef F = Map<String, dynamic> Function();",
-        errors: [
-          expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 12, 7),
-          expectedError(ParserErrorCode.EXPECTED_TOKEN, 12, 7),
-          expectedError(ParserErrorCode.INVALID_GENERIC_FUNCTION_TYPE, 10, 1),
-        ]);
-  }
-
-  void test_invalidUnicodeEscape_incomplete_noDigits() {
-    Expression expression = parseStringLiteral("'\\u{'");
-    expectNotNullIfNoErrors(expression);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.INVALID_UNICODE_ESCAPE, 1, 3)]);
-  }
-
-  void test_invalidUnicodeEscape_incomplete_someDigits() {
-    Expression expression = parseStringLiteral("'\\u{0A'");
-    expectNotNullIfNoErrors(expression);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.INVALID_UNICODE_ESCAPE, 1, 5)]);
-  }
-
-  void test_invalidUnicodeEscape_invalidDigit() {
-    Expression expression = parseStringLiteral("'\\u0 and some more'");
-    expectNotNullIfNoErrors(expression);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.INVALID_UNICODE_ESCAPE, 1, 3)]);
-  }
-
-  void test_invalidUnicodeEscape_tooFewDigits_fixed() {
-    Expression expression = parseStringLiteral("'\\u04'");
-    expectNotNullIfNoErrors(expression);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.INVALID_UNICODE_ESCAPE, 1, 4)]);
-  }
-
-  void test_invalidUnicodeEscape_tooFewDigits_variable() {
-    Expression expression = parseStringLiteral("'\\u{}'");
-    expectNotNullIfNoErrors(expression);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.INVALID_UNICODE_ESCAPE, 1, 4)]);
-  }
-
-  void test_invalidUnicodeEscape_tooManyDigits_variable() {
-    Expression expression = parseStringLiteral("'\\u{12345678}'");
-    expectNotNullIfNoErrors(expression);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.INVALID_CODE_POINT, 1, 9)]);
-  }
-
-  void test_libraryDirectiveNotFirst() {
-    parseCompilationUnit("import 'x.dart'; library l;", errors: [
-      expectedError(ParserErrorCode.LIBRARY_DIRECTIVE_NOT_FIRST, 17, 7)
-    ]);
-  }
-
-  void test_libraryDirectiveNotFirst_afterPart() {
-    CompilationUnit unit = parseCompilationUnit("part 'a.dart';\nlibrary l;",
-        errors: [
-          expectedError(ParserErrorCode.LIBRARY_DIRECTIVE_NOT_FIRST, 15, 7)
-        ]);
-    expect(unit, isNotNull);
-  }
-
-  void test_localFunction_annotation() {
-    CompilationUnit unit =
-        parseCompilationUnit("class C { m() { @Foo f() {} } }");
-    expect(unit.declarations, hasLength(1));
-    ClassDeclaration declaration = unit.declarations[0];
-    expect(declaration.members, hasLength(1));
-    MethodDeclaration member = declaration.members[0];
-    BlockFunctionBody body = member.body;
-    expect(body.block.statements, hasLength(1));
-    FunctionDeclarationStatement statement = body.block.statements[0];
-    expect(statement.functionDeclaration.metadata, hasLength(1));
-    Annotation metadata = statement.functionDeclaration.metadata[0];
-    expect(metadata.name.name, 'Foo');
-  }
-
-  void test_localFunctionDeclarationModifier_abstract() {
-    parseCompilationUnit("class C { m() { abstract f() {} } }",
-        errors: [expectedError(ParserErrorCode.EXTRANEOUS_MODIFIER, 16, 8)]);
-  }
-
-  void test_localFunctionDeclarationModifier_external() {
-    parseCompilationUnit("class C { m() { external f() {} } }",
-        errors: [expectedError(ParserErrorCode.EXTRANEOUS_MODIFIER, 16, 8)]);
-  }
-
-  void test_localFunctionDeclarationModifier_factory() {
-    parseCompilationUnit("class C { m() { factory f() {} } }",
-        errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 16, 7)]);
-  }
-
-  void test_localFunctionDeclarationModifier_static() {
-    parseCompilationUnit("class C { m() { static f() {} } }",
-        errors: [expectedError(ParserErrorCode.EXTRANEOUS_MODIFIER, 16, 6)]);
-  }
-
-  void test_method_invalidTypeParameterExtends() {
-    // Regression test for https://github.com/dart-lang/sdk/issues/25739.
-
-    // TODO(jmesserly): ideally we'd be better at parser recovery here.
-    createParser('f<E>(E extends num p);');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 7)]);
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.parameters.toString(), '(E)',
-        reason: 'parser recovers what it can');
-  }
-
-  void test_method_invalidTypeParameters() {
-    createParser('void m<E, hello!>() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 10, 5)]);
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.typeParameters.toString(), '<E, hello>',
-        reason: 'parser recovers what it can');
-  }
-
-  void test_missing_closing_bracket_issue37528() {
-    final code = '\${foo';
-    createParser(code);
-    final result = fasta.scanString(code);
-    expect(result.hasErrors, isTrue);
-    var token = parserProxy.fastaParser.syntheticPreviousToken(result.tokens);
-    try {
-      parserProxy.fastaParser.parseExpression(token);
-      // TODO(danrubel): Replace this test once root cause is found
-      fail('exception expected');
-    } catch (e) {
-      var msg = e.toString();
-      expect(msg.contains('test_missing_closing_bracket_issue37528'), isTrue);
-    }
-  }
-
-  void test_missingAssignableSelector_identifiersAssigned() {
-    parseExpression("x.y = y;", expectedEndOffset: 7);
-  }
-
-  void test_missingAssignableSelector_prefix_minusMinus_literal() {
-    parseExpression("--0", errors: [
-      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 2, 1)
-    ]);
-  }
-
-  void test_missingAssignableSelector_prefix_plusPlus_literal() {
-    parseExpression("++0", errors: [
-      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 2, 1)
-    ]);
-  }
-
-  void test_missingAssignableSelector_selector() {
-    parseExpression("x(y)(z).a++");
-  }
-
-  void test_missingAssignableSelector_superPrimaryExpression() {
-    CompilationUnit unit = parseCompilationUnit('main() {super;}', errors: [
-      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 8, 5)
-    ]);
-    FunctionDeclaration declaration = unit.declarations.first;
-    BlockFunctionBody blockBody = declaration.functionExpression.body;
-    ExpressionStatement statement = blockBody.block.statements.first;
-    Expression expression = statement.expression;
-    expect(expression, isSuperExpression);
-    SuperExpression superExpression = expression;
-    expect(superExpression.superKeyword, isNotNull);
-  }
-
-  void test_missingAssignableSelector_superPropertyAccessAssigned() {
-    parseExpression("super.x = x;", expectedEndOffset: 11);
-  }
-
-  void test_missingCatchOrFinally() {
-    TryStatement statement = parseStatement('try {}');
-    expectNotNullIfNoErrors(statement);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_CATCH_OR_FINALLY, 0, 3)]);
-    expect(statement, isNotNull);
-  }
-
-  void test_missingClosingParenthesis() {
-    createParser('(int a, int b ;',
-        expectedEndOffset: 14 /* parsing ends at synthetic ')' */);
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    listener.errors
-        .contains(expectedError(ParserErrorCode.EXPECTED_TOKEN, 14, 1));
-  }
-
-  void test_missingConstFinalVarOrType_static() {
-    parseCompilationUnit("class A { static f; }", errors: [
-      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 17, 1)
-    ]);
-  }
-
-  void test_missingConstFinalVarOrType_topLevel() {
-    parseCompilationUnit('a;', errors: [
-      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 0, 1)
-    ]);
-  }
-
-  void test_missingEnumBody() {
-    createParser('enum E;', expectedEndOffset: 6);
-    EnumDeclaration declaration = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(declaration);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.MISSING_ENUM_BODY, 6, 1)]);
-  }
-
-  void test_missingEnumComma() {
-    createParser('enum E {one two}');
-    EnumDeclaration declaration = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(declaration);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 12, 3)]);
-  }
-
-  void test_missingExpressionInThrow() {
-    ThrowExpression expression =
-        (parseStatement('throw;') as ExpressionStatement).expression;
-    expectNotNullIfNoErrors(expression);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_EXPRESSION_IN_THROW, 5, 1)]);
-  }
-
-  void test_missingFunctionBody_emptyNotAllowed() {
-    createParser(';');
-    FunctionBody functionBody = parser.parseFunctionBody(
-        false, ParserErrorCode.MISSING_FUNCTION_BODY, false);
-    expectNotNullIfNoErrors(functionBody);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 0, 1)]);
-  }
-
-  void test_missingFunctionBody_invalid() {
-    createParser('return 0;');
-    FunctionBody functionBody = parser.parseFunctionBody(
-        false, ParserErrorCode.MISSING_FUNCTION_BODY, false);
-    expectNotNullIfNoErrors(functionBody);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 0, 6)]);
-  }
-
-  void test_missingFunctionParameters_local_nonVoid_block() {
-    // The parser does not recognize this as a function declaration, so it tries
-    // to parse it as an expression statement. It isn't clear what the best
-    // error message is in this case.
-    parseStatement("int f { return x;}", expectedEndOffset: 6);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 4, 1)]);
-  }
-
-  void test_missingFunctionParameters_local_nonVoid_expression() {
-    // The parser does not recognize this as a function declaration, so it tries
-    // to parse it as an expression statement. It isn't clear what the best
-    // error message is in this case.
-    parseStatement("int f => x;");
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 6, 2)]);
-  }
-
-  void test_missingFunctionParameters_local_void_block() {
-    parseStatement("void f { return x;}", expectedEndOffset: 7);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 5, 1)]);
-  }
-
-  void test_missingFunctionParameters_local_void_expression() {
-    parseStatement("void f => x;");
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 7, 2)]);
-  }
-
-  void test_missingFunctionParameters_topLevel_nonVoid_block() {
-    parseCompilationUnit("int f { return x;}", errors: [
-      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 4, 1)
-    ]);
-  }
-
-  void test_missingFunctionParameters_topLevel_nonVoid_expression() {
-    parseCompilationUnit("int f => x;", errors: [
-      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 4, 1)
-    ]);
-  }
-
-  void test_missingFunctionParameters_topLevel_void_block() {
-    CompilationUnit unit = parseCompilationUnit("void f { return x;}", errors: [
-      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 5, 1)
-    ]);
-    FunctionDeclaration funct = unit.declarations[0];
-    expect(funct.functionExpression.parameters, hasLength(0));
-  }
-
-  void test_missingFunctionParameters_topLevel_void_expression() {
-    CompilationUnit unit = parseCompilationUnit("void f => x;", errors: [
-      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 5, 1)
-    ]);
-    FunctionDeclaration funct = unit.declarations[0];
-    expect(funct.functionExpression.parameters, hasLength(0));
-  }
-
-  void test_missingIdentifier_afterOperator() {
-    createParser('1 *');
-    BinaryExpression expression = parser.parseMultiplicativeExpression();
-    expectNotNullIfNoErrors(expression);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 3, 0)]);
-  }
-
-  void test_missingIdentifier_beforeClosingCurly() {
-    createParser('int}', expectedEndOffset: 3);
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 0, 3),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 0, 3)
-    ]);
-  }
-
-  void test_missingIdentifier_inEnum() {
-    createParser('enum E {, TWO}');
-    EnumDeclaration declaration = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(declaration);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 1)]);
-  }
-
-  void test_missingIdentifier_inParameterGroupNamed() {
-    createParser('(a, {})');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 5, 1)]);
-  }
-
-  void test_missingIdentifier_inParameterGroupOptional() {
-    createParser('(a, [])');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 5, 1)]);
-  }
-
-  void test_missingIdentifier_inSymbol_afterPeriod() {
-    SymbolLiteral literal = parseSymbolLiteral('#a.');
-    expectNotNullIfNoErrors(literal);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 3, 1)]);
-  }
-
-  void test_missingIdentifier_inSymbol_first() {
-    SymbolLiteral literal = parseSymbolLiteral('#');
-    expectNotNullIfNoErrors(literal);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 1, 1)]);
-  }
-
-  void test_missingIdentifierForParameterGroup() {
-    createParser('(,)');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 1, 1)]);
-  }
-
-  void test_missingKeywordOperator() {
-    createParser('+(x) {}');
-    MethodDeclaration method = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(method);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_KEYWORD_OPERATOR, 0, 1)]);
-  }
-
-  void test_missingKeywordOperator_parseClassMember() {
-    createParser('+() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_KEYWORD_OPERATOR, 0, 1)]);
-  }
-
-  void test_missingKeywordOperator_parseClassMember_afterTypeName() {
-    createParser('int +() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_KEYWORD_OPERATOR, 4, 1)]);
-  }
-
-  void test_missingKeywordOperator_parseClassMember_afterVoid() {
-    createParser('void +() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_KEYWORD_OPERATOR, 5, 1)]);
-  }
-
-  void test_missingMethodParameters_void_block() {
-    createParser('void m {} }', expectedEndOffset: 10);
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 5, 1)]);
-    expect(member, isMethodDeclaration);
-    MethodDeclaration method = member;
-    expect(method.parameters, hasLength(0));
-  }
-
-  void test_missingMethodParameters_void_expression() {
-    createParser('void m => null; }', expectedEndOffset: 16);
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 5, 1)]);
-  }
-
-  void test_missingNameForNamedParameter_colon() {
-    createParser('({int : 0})');
-    FormalParameter parameter =
-        parser.parseFormalParameterList(inFunctionType: true).parameters[0];
-    expectNotNullIfNoErrors(parameter);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 1),
-      expectedError(ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE, 6, 1)
-    ]);
-    expect(parameter.identifier, isNotNull);
-  }
-
-  void test_missingNameForNamedParameter_equals() {
-    createParser('({int = 0})');
-    FormalParameter parameter =
-        parser.parseFormalParameterList(inFunctionType: true).parameters[0];
-    expectNotNullIfNoErrors(parameter);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 1),
-      expectedError(ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE, 6, 1)
-    ]);
-    expect(parameter.identifier, isNotNull);
-  }
-
-  void test_missingNameForNamedParameter_noDefault() {
-    createParser('({int})');
-    FormalParameter parameter =
-        parser.parseFormalParameterList(inFunctionType: true).parameters[0];
-    expectNotNullIfNoErrors(parameter);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 5, 1)]);
-    expect(parameter.identifier, isNotNull);
-  }
-
-  void test_missingNameInLibraryDirective() {
-    CompilationUnit unit = parseCompilationUnit("library;",
-        errors: [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 7, 1)]);
-    expect(unit, isNotNull);
-  }
-
-  void test_missingNameInPartOfDirective() {
-    CompilationUnit unit = parseCompilationUnit("part of;",
-        errors: [expectedError(ParserErrorCode.EXPECTED_STRING_LITERAL, 7, 1)]);
-    expect(unit, isNotNull);
-  }
-
-  void test_missingPrefixInDeferredImport() {
-    parseCompilationUnit("import 'foo.dart' deferred;", errors: [
-      expectedError(ParserErrorCode.MISSING_PREFIX_IN_DEFERRED_IMPORT, 18, 8)
-    ]);
-  }
-
-  void test_missingStartAfterSync() {
-    createParser('sync {}');
-    FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
-    expectNotNullIfNoErrors(functionBody);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_STAR_AFTER_SYNC, 0, 4)]);
-  }
-
-  void test_missingStatement() {
-    parseStatement("is");
-    listener.assertErrors([
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 0, 2),
-      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 2, 0),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 2, 0)
-    ]);
-  }
-
-  void test_missingStatement_afterVoid() {
-    parseStatement("void;");
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 4, 1)]);
-  }
-
-  void test_missingTerminatorForParameterGroup_named() {
-    createParser('(a, {b: 0)');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    listener
-        .assertErrors([expectedError(ScannerErrorCode.EXPECTED_TOKEN, 9, 1)]);
-  }
-
-  void test_missingTerminatorForParameterGroup_optional() {
-    createParser('(a, [b = 0)');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    listener
-        .assertErrors([expectedError(ScannerErrorCode.EXPECTED_TOKEN, 10, 1)]);
-  }
-
-  void test_missingTypedefParameters_nonVoid() {
-    parseCompilationUnit("typedef int F;", errors: [
-      expectedError(ParserErrorCode.MISSING_TYPEDEF_PARAMETERS, 13, 1)
-    ]);
-  }
-
-  void test_missingTypedefParameters_typeParameters() {
-    parseCompilationUnit("typedef F<E>;", errors: [
-      expectedError(ParserErrorCode.MISSING_TYPEDEF_PARAMETERS, 12, 1)
-    ]);
-  }
-
-  void test_missingTypedefParameters_void() {
-    parseCompilationUnit("typedef void F;", errors: [
-      expectedError(ParserErrorCode.MISSING_TYPEDEF_PARAMETERS, 14, 1)
-    ]);
-  }
-
-  void test_missingVariableInForEach() {
-    Statement statement = parseStatement('for (a < b in foo) {}');
-    expectNotNullIfNoErrors(statement);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 7, 1)]);
-  }
-
-  void test_mixedParameterGroups_namedPositional() {
-    createParser('(a, {b}, [c])');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
-  }
-
-  void test_mixedParameterGroups_positionalNamed() {
-    createParser('(a, [b], {c})');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
-  }
-
-  void test_mixin_application_lacks_with_clause() {
-    parseCompilationUnit("class Foo = Bar;",
-        errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 15, 1)]);
-  }
-
-  void test_multipleExtendsClauses() {
-    parseCompilationUnit("class A extends B extends C {}", errors: [
-      expectedError(ParserErrorCode.MULTIPLE_EXTENDS_CLAUSES, 18, 7)
-    ]);
-  }
-
-  void test_multipleImplementsClauses() {
-    parseCompilationUnit("class A implements B implements C {}", errors: [
-      expectedError(ParserErrorCode.MULTIPLE_IMPLEMENTS_CLAUSES, 21, 10)
-    ]);
-  }
-
-  void test_multipleLibraryDirectives() {
-    parseCompilationUnit("library l; library m;", errors: [
-      expectedError(ParserErrorCode.MULTIPLE_LIBRARY_DIRECTIVES, 11, 7)
-    ]);
-  }
-
-  void test_multipleNamedParameterGroups() {
-    createParser('(a, {b}, {c})');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
-  }
-
-  void test_multiplePartOfDirectives() {
-    parseCompilationUnit("part of l; part of m;", errors: [
-      expectedError(ParserErrorCode.MULTIPLE_PART_OF_DIRECTIVES, 11, 4)
-    ]);
-  }
-
-  void test_multiplePositionalParameterGroups() {
-    createParser('(a, [b], [c])');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
-  }
-
-  void test_multipleVariablesInForEach() {
-    Statement statement = parseStatement('for (int a, b in foo) {}');
-    expectNotNullIfNoErrors(statement);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 10, 1)]);
-  }
-
-  void test_multipleWithClauses() {
-    parseCompilationUnit("class A extends B with C with D {}",
-        errors: [expectedError(ParserErrorCode.MULTIPLE_WITH_CLAUSES, 25, 4)]);
-  }
-
-  void test_namedFunctionExpression() {
-    Expression expression;
-    createParser('f() {}');
-    expression = parser.parsePrimaryExpression();
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.NAMED_FUNCTION_EXPRESSION, 0, 1)]);
-    expect(expression, isFunctionExpression);
-  }
-
-  void test_namedParameterOutsideGroup() {
-    createParser('(a, b : 0)');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.NAMED_PARAMETER_OUTSIDE_GROUP, 6, 1)]);
-    expect(list.parameters[0].isRequired, isTrue);
-    expect(list.parameters[1].isNamed, isTrue);
-  }
-
-  void test_nonConstructorFactory_field() {
-    createParser('factory int x;', expectedEndOffset: 12);
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 12, 1),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 12, 1)
-    ]);
-  }
-
-  void test_nonConstructorFactory_method() {
-    createParser('factory int m() {}', expectedEndOffset: 12);
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 12, 1),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 12, 1)
-    ]);
-  }
-
-  void test_nonIdentifierLibraryName_library() {
-    CompilationUnit unit = parseCompilationUnit("library 'lib';",
-        errors: [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 5)]);
-    expect(unit, isNotNull);
-  }
-
-  void test_nonIdentifierLibraryName_partOf() {
-    CompilationUnit unit = parseCompilationUnit("part of 3;", errors: [
-      expectedError(ParserErrorCode.EXPECTED_STRING_LITERAL, 8, 1),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 8, 1),
-      expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 8, 1),
-      expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 9, 1)
-    ]);
-    expect(unit, isNotNull);
-  }
-
-  void test_nonPartOfDirectiveInPart_after() {
-    parseCompilationUnit("part of l; part 'f.dart';", errors: [
-      expectedError(ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART, 11, 4)
-    ]);
-  }
-
-  void test_nonPartOfDirectiveInPart_before() {
-    // TODO(brianwilkerson) Remove codes when highlighting is fixed.
-    parseCompilationUnit("part 'f.dart'; part of m;", codes: [
-      ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART
-    ], errors: [
-      expectedError(ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART, 0, 4)
-    ]);
-  }
-
-  void test_nonUserDefinableOperator() {
-    createParser('operator +=(int x) => x + 1;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.INVALID_OPERATOR, 9, 2)]);
-  }
-
-  void test_optionalAfterNormalParameters_named() {
-    parseCompilationUnit("f({a}, b) {}",
-        errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 5, 1)]);
-  }
-
-  void test_optionalAfterNormalParameters_positional() {
-    parseCompilationUnit("f([a], b) {}",
-        errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 5, 1)]);
-  }
-
-  void test_parseCascadeSection_missingIdentifier() {
-    MethodInvocation methodInvocation = parseCascadeSection('..()');
-    expectNotNullIfNoErrors(methodInvocation);
-    listener.assertErrors([
-      // Cascade section is preceded by `null` in this test
-      // and error is reported on '('.
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 1)
-    ]);
-    expect(methodInvocation.target, isNull);
-    expect(methodInvocation.methodName.name, "");
-    expect(methodInvocation.typeArguments, isNull);
-    expect(methodInvocation.argumentList.arguments, hasLength(0));
-  }
-
-  void test_parseCascadeSection_missingIdentifier_typeArguments() {
-    MethodInvocation methodInvocation = parseCascadeSection('..<E>()');
-    expectNotNullIfNoErrors(methodInvocation);
-    listener.assertErrors([
-      // Cascade section is preceded by `null` in this test
-      // and error is reported on '<'.
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 1)
-    ]);
-    expect(methodInvocation.target, isNull);
-    expect(methodInvocation.methodName.name, "");
-    expect(methodInvocation.typeArguments, isNotNull);
-    expect(methodInvocation.argumentList.arguments, hasLength(0));
-  }
-
-  void test_partialNamedConstructor() {
-    parseCompilationUnit('class C { C. }', errors: [
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 13, 1),
-      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 10, 1),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 13, 1),
-    ]);
-  }
-
-  void test_positionalAfterNamedArgument() {
-    createParser('(x: 1, 2)');
-    ArgumentList list = parser.parseArgumentList();
-    expectNotNullIfNoErrors(list);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.POSITIONAL_AFTER_NAMED_ARGUMENT, 7, 1)]);
-  }
-
-  void test_positionalParameterOutsideGroup() {
-    createParser('(a, b = 0)');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.NAMED_PARAMETER_OUTSIDE_GROUP, 6, 1)]);
-    expect(list.parameters[0].isRequired, isTrue);
-    expect(list.parameters[1].isNamed, isTrue);
-  }
-
-  void test_redirectingConstructorWithBody_named() {
-    createParser('C.x() : this() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.REDIRECTING_CONSTRUCTOR_WITH_BODY, 15, 1)
-    ]);
-  }
-
-  void test_redirectingConstructorWithBody_unnamed() {
-    createParser('C() : this.x() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.REDIRECTING_CONSTRUCTOR_WITH_BODY, 15, 1)
-    ]);
-  }
-
-  void test_redirectionInNonFactoryConstructor() {
-    createParser('C() = D;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([
-      expectedError(
-          ParserErrorCode.REDIRECTION_IN_NON_FACTORY_CONSTRUCTOR, 4, 1)
-    ]);
-  }
-
-  void test_setterInFunction_block() {
-    parseStatement("set x(v) {_x = v;}");
-    listener
-        .assertErrors([expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 0, 3)]);
-  }
-
-  void test_setterInFunction_expression() {
-    parseStatement("set x(v) => _x = v;");
-    listener
-        .assertErrors([expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 0, 3)]);
-  }
-
-  void test_staticAfterConst() {
-    createParser('final static int f;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 6, 6)]);
-  }
-
-  void test_staticAfterFinal() {
-    createParser('const static int f;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 6, 6),
-      expectedError(CompileTimeErrorCode.CONST_NOT_INITIALIZED, 17, 1)
-    ]);
-  }
-
-  void test_staticAfterVar() {
-    createParser('var static f;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 4, 6)]);
-  }
-
-  void test_staticConstructor() {
-    createParser('static C.m() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.STATIC_CONSTRUCTOR, 0, 6)]);
-  }
-
-  void test_staticGetterWithoutBody() {
-    createParser('static get m;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 12, 1)]);
-  }
-
-  void test_staticOperator_noReturnType() {
-    createParser('static operator +(int x) => x + 1;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.STATIC_OPERATOR, 0, 6)]);
-  }
-
-  void test_staticOperator_returnType() {
-    createParser('static int operator +(int x) => x + 1;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.STATIC_OPERATOR, 0, 6)]);
-  }
-
-  void test_staticOperatorNamedMethod() {
-    // operator can be used as a method name
-    parseCompilationUnit('class C { static operator(x) => x; }');
-  }
-
-  void test_staticSetterWithoutBody() {
-    createParser('static set m(x);');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 15, 1)]);
-  }
-
-  void test_staticTopLevelDeclaration_class() {
-    parseCompilationUnit("static class C {}", errors: [
-      expectedError(ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION, 0, 6)
-    ]);
-  }
-
-  void test_staticTopLevelDeclaration_enum() {
-    parseCompilationUnit("static enum E { v }", errors: [
-      expectedError(ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION, 0, 6)
-    ]);
-  }
-
-  void test_staticTopLevelDeclaration_function() {
-    parseCompilationUnit("static f() {}", errors: [
-      expectedError(ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION, 0, 6)
-    ]);
-  }
-
-  void test_staticTopLevelDeclaration_typedef() {
-    parseCompilationUnit("static typedef F();", errors: [
-      expectedError(ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION, 0, 6)
-    ]);
-  }
-
-  void test_staticTopLevelDeclaration_variable() {
-    parseCompilationUnit("static var x;", errors: [
-      expectedError(ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION, 0, 6)
-    ]);
-  }
-
-  void test_string_unterminated_interpolation_block() {
-    parseCompilationUnit(r'''
-m() {
- {
- '${${
-''', codes: [
-      ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
-      ScannerErrorCode.EXPECTED_TOKEN,
-      ScannerErrorCode.EXPECTED_TOKEN,
-      ScannerErrorCode.EXPECTED_TOKEN,
-      ScannerErrorCode.EXPECTED_TOKEN,
-      ParserErrorCode.EXPECTED_TOKEN,
-      ParserErrorCode.EXPECTED_TOKEN
-    ]);
-  }
-
-  void test_switchCase_missingColon() {
-    SwitchStatement statement = parseStatement('switch (a) {case 1 return 0;}');
-    expect(statement, isNotNull);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 19, 6)]);
-  }
-
-  void test_switchDefault_missingColon() {
-    SwitchStatement statement =
-        parseStatement('switch (a) {default return 0;}');
-    expect(statement, isNotNull);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 20, 6)]);
-  }
-
-  void test_switchHasCaseAfterDefaultCase() {
-    SwitchStatement statement =
-        parseStatement('switch (a) {default: return 0; case 1: return 1;}');
-    expectNotNullIfNoErrors(statement);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.SWITCH_HAS_CASE_AFTER_DEFAULT_CASE, 31, 4)
-    ]);
-  }
-
-  void test_switchHasCaseAfterDefaultCase_repeated() {
-    SwitchStatement statement = parseStatement(
-        'switch (a) {default: return 0; case 1: return 1; case 2: return 2;}');
-    expectNotNullIfNoErrors(statement);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.SWITCH_HAS_CASE_AFTER_DEFAULT_CASE, 31, 4),
-      expectedError(ParserErrorCode.SWITCH_HAS_CASE_AFTER_DEFAULT_CASE, 49, 4)
-    ]);
-  }
-
-  void test_switchHasMultipleDefaultCases() {
-    SwitchStatement statement =
-        parseStatement('switch (a) {default: return 0; default: return 1;}');
-    expectNotNullIfNoErrors(statement);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.SWITCH_HAS_MULTIPLE_DEFAULT_CASES, 31, 7)
-    ]);
-  }
-
-  void test_switchHasMultipleDefaultCases_repeated() {
-    SwitchStatement statement = parseStatement(
-        'switch (a) {default: return 0; default: return 1; default: return 2;}');
-    expectNotNullIfNoErrors(statement);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.SWITCH_HAS_MULTIPLE_DEFAULT_CASES, 31, 7),
-      expectedError(ParserErrorCode.SWITCH_HAS_MULTIPLE_DEFAULT_CASES, 50, 7)
-    ]);
-  }
-
-  void test_switchMissingBlock() {
-    SwitchStatement statement =
-        parseStatement('switch (a) return;', expectedEndOffset: 11);
-    expect(statement, isNotNull);
-    listener.assertErrors([expectedError(ParserErrorCode.EXPECTED_BODY, 9, 1)]);
-  }
-
-  void test_topLevel_getter() {
-    createParser('get x => 7;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    assertNoErrors();
-    expect(member, isFunctionDeclaration);
-    FunctionDeclaration function = member;
-    expect(function.functionExpression.parameters, isNull);
-  }
-
-  void test_topLevelFactory_withFunction() {
-    parseCompilationUnit('factory Function() x = null;', errors: [
-      expectedError(ParserErrorCode.FACTORY_TOP_LEVEL_DECLARATION, 0, 7)
-    ]);
-  }
-
-  void test_topLevelOperator_withFunction() {
-    parseCompilationUnit('operator Function() x = null;',
-        errors: [expectedError(ParserErrorCode.TOP_LEVEL_OPERATOR, 0, 8)]);
-  }
-
-  void test_topLevelOperator_withoutOperator() {
-    createParser('+(bool x, bool y) => x | y;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.TOP_LEVEL_OPERATOR, 0, 1)]);
-  }
-
-  void test_topLevelOperator_withoutType() {
-    parseCompilationUnit('operator +(bool x, bool y) => x | y;',
-        errors: [expectedError(ParserErrorCode.TOP_LEVEL_OPERATOR, 0, 8)]);
-  }
-
-  void test_topLevelOperator_withType() {
-    parseCompilationUnit('bool operator +(bool x, bool y) => x | y;',
-        errors: [expectedError(ParserErrorCode.TOP_LEVEL_OPERATOR, 5, 8)]);
-  }
-
-  void test_topLevelOperator_withVoid() {
-    parseCompilationUnit('void operator +(bool x, bool y) => x | y;',
-        errors: [expectedError(ParserErrorCode.TOP_LEVEL_OPERATOR, 5, 8)]);
-  }
-
-  void test_topLevelVariable_withMetadata() {
-    parseCompilationUnit("String @A string;", codes: [
-      ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE,
-      ParserErrorCode.EXPECTED_TOKEN,
-      ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE
-    ]);
-  }
-
-  void test_typedef_incomplete() {
-    // TODO(brianwilkerson) Improve recovery for this case.
-    parseCompilationUnit('''
-class A {}
-class B extends A {}
-
-typedef T
-
-main() {
-  Function<
-}
-''', errors: [
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 49, 1),
-      expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 51, 1),
-    ]);
-  }
-
-  void test_typedef_namedFunction() {
-    parseCompilationUnit('typedef void Function();',
-        codes: [ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD]);
-  }
-
-  void test_typedefInClass_withoutReturnType() {
-    parseCompilationUnit("class C { typedef F(x); }",
-        errors: [expectedError(ParserErrorCode.TYPEDEF_IN_CLASS, 10, 7)]);
-  }
-
-  void test_typedefInClass_withReturnType() {
-    parseCompilationUnit("class C { typedef int F(int x); }",
-        errors: [expectedError(ParserErrorCode.TYPEDEF_IN_CLASS, 10, 7)]);
-  }
-
-  void test_unexpectedCommaThenInterpolation() {
-    // https://github.com/Dart-Code/Dart-Code/issues/1548
-    parseCompilationUnit(r"main() { String s = 'a' 'b', 'c$foo'; return s; }",
-        errors: [
-          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 29, 2),
-          expectedError(ParserErrorCode.EXPECTED_TOKEN, 29, 2),
-        ]);
-  }
-
-  void test_unexpectedTerminatorForParameterGroup_named() {
-    createParser('(a, b})');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 5, 1)]);
-  }
-
-  void test_unexpectedTerminatorForParameterGroup_optional() {
-    createParser('(a, b])');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 5, 1)]);
-  }
-
-  void test_unexpectedToken_endOfFieldDeclarationStatement() {
-    parseStatement("String s = (null));", expectedEndOffset: 17);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 16, 1)]);
-  }
-
-  void test_unexpectedToken_invalidPostfixExpression() {
-    parseExpression("f()++", errors: [
-      expectedError(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 3, 2)
-    ]);
-  }
-
-  void test_unexpectedToken_invalidPrefixExpression() {
-    parseExpression("++f()", errors: [
-      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 4, 1)
-    ]);
-  }
-
-  void test_unexpectedToken_returnInExpressionFunctionBody() {
-    parseCompilationUnit("f() => return null;",
-        errors: [expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 7, 6)]);
-  }
-
-  void test_unexpectedToken_semicolonBetweenClassMembers() {
-    createParser('class C { int x; ; int y;}');
-    ClassDeclaration declaration = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(declaration);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.EXPECTED_CLASS_MEMBER, 17, 1)]);
-  }
-
-  void test_unexpectedToken_semicolonBetweenCompilationUnitMembers() {
-    parseCompilationUnit("int x; ; int y;",
-        errors: [expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 7, 1)]);
-  }
-
-  void test_unterminatedString_at_eof() {
-    // Although the "unterminated string" error message is produced by the
-    // scanner, we need to verify that the parser can handle the tokens
-    // produced by the scanner when an unterminated string is encountered.
-    parseCompilationUnit(r'''
-void main() {
-  var x = "''', errors: [
-      expectedError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 24, 1),
-      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 25, 1),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 24, 1)
-    ]);
-  }
-
-  void test_unterminatedString_at_eol() {
-    // Although the "unterminated string" error message is produced by the
-    // scanner, we need to verify that the parser can handle the tokens
-    // produced by the scanner when an unterminated string is encountered.
-    parseCompilationUnit(r'''
-void main() {
-  var x = "
-;
-}
-''', errors: [
-      expectedError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 24, 1)
-    ]);
-  }
-
-  void test_unterminatedString_multiline_at_eof_3_quotes() {
-    // Although the "unterminated string" error message is produced by the
-    // scanner, we need to verify that the parser can handle the tokens
-    // produced by the scanner when an unterminated string is encountered.
-    // TODO(brianwilkerson) Remove codes when highlighting is fixed.
-    parseCompilationUnit(r'''
-void main() {
-  var x = """''', codes: [
-      ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
-      ScannerErrorCode.EXPECTED_TOKEN,
-      ParserErrorCode.EXPECTED_TOKEN
-    ], errors: [
-      expectedError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 24, 1),
-      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 30, 0),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 30, 0)
-    ]);
-  }
-
-  void test_unterminatedString_multiline_at_eof_4_quotes() {
-    // Although the "unterminated string" error message is produced by the
-    // scanner, we need to verify that the parser can handle the tokens
-    // produced by the scanner when an unterminated string is encountered.
-    // TODO(brianwilkerson) Remove codes when highlighting is fixed.
-    parseCompilationUnit(r'''
-void main() {
-  var x = """"''', codes: [
-      ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
-      ScannerErrorCode.EXPECTED_TOKEN,
-      ParserErrorCode.EXPECTED_TOKEN
-    ], errors: [
-      expectedError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 24, 1),
-      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 31, 0),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 31, 0)
-    ]);
-  }
-
-  void test_unterminatedString_multiline_at_eof_5_quotes() {
-    // Although the "unterminated string" error message is produced by the
-    // scanner, we need to verify that the parser can handle the tokens
-    // produced by the scanner when an unterminated string is encountered.
-    // TODO(brianwilkerson) Remove codes when highlighting is fixed.
-    parseCompilationUnit(r'''
-void main() {
-  var x = """""''', codes: [
-      ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
-      ScannerErrorCode.EXPECTED_TOKEN,
-      ParserErrorCode.EXPECTED_TOKEN
-    ], errors: [
-      expectedError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 28, 1),
-      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 32, 0),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 32, 0)
-    ]);
-  }
-
-  void test_useOfUnaryPlusOperator() {
-    createParser('+x');
-    Expression expression = parser.parseUnaryExpression();
-    expectNotNullIfNoErrors(expression);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 0, 1)]);
-    BinaryExpression binaryExpression = expression;
-    expect(binaryExpression.leftOperand.isSynthetic, isTrue);
-    expect(binaryExpression.rightOperand.isSynthetic, isFalse);
-    SimpleIdentifier identifier = binaryExpression.rightOperand;
-    expect(identifier.name, 'x');
-  }
-
-  void test_varAndType_field() {
-    parseCompilationUnit("class C { var int x; }",
-        errors: [expectedError(ParserErrorCode.VAR_AND_TYPE, 10, 3)]);
-  }
-
-  void test_varAndType_local() {
-    // This is currently reporting EXPECTED_TOKEN for a missing semicolon, but
-    // this would be a better error message.
-    parseStatement("var int x;");
-    listener.assertErrors([expectedError(ParserErrorCode.VAR_AND_TYPE, 0, 3)]);
-  }
-
-  void test_varAndType_parameter() {
-    // This is currently reporting EXPECTED_TOKEN for a missing semicolon, but
-    // this would be a better error message.
-    createParser('(var int x)');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    listener.assertErrors([expectedError(ParserErrorCode.VAR_AND_TYPE, 1, 3)]);
-  }
-
-  void test_varAndType_topLevelVariable() {
-    parseCompilationUnit("var int x;",
-        errors: [expectedError(ParserErrorCode.VAR_AND_TYPE, 0, 3)]);
-  }
-
-  void test_varAsTypeName_as() {
-    parseExpression("x as var",
-        expectedEndOffset: 5,
-        errors: [expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 5, 3)]);
-  }
-
-  void test_varClass() {
-    parseCompilationUnit("var class C {}", errors: [
-      // Fasta interprets the `var` as a malformed top level var
-      // and `class` as the start of a class declaration.
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 4, 5),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 4, 5),
-    ]);
-  }
-
-  void test_varEnum() {
-    parseCompilationUnit("var enum E {ONE}", errors: [
-      // Fasta interprets the `var` as a malformed top level var
-      // and `enum` as the start of an enum declaration.
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 4, 4),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 4, 4),
-    ]);
-  }
-
-  void test_varReturnType() {
-    createParser('var m() {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.VAR_RETURN_TYPE, 0, 3)]);
-  }
-
-  void test_varTypedef() {
-    parseCompilationUnit("var typedef F();", errors: [
-      // Fasta interprets the `var` as a malformed top level var
-      // and `typedef` as the start of an typedef declaration.
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 4, 7),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 4, 7),
-    ]);
-  }
-
-  void test_voidParameter() {
-    NormalFormalParameter parameter =
-        parseFormalParameterList('(void a)').parameters[0];
-    expectNotNullIfNoErrors(parameter);
-    assertNoErrors();
-  }
-
-  void test_voidVariable_parseClassMember_initializer() {
-    createParser('void x = 0;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    assertNoErrors();
-  }
-
-  void test_voidVariable_parseClassMember_noInitializer() {
-    createParser('void x;');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    assertNoErrors();
-  }
-
-  void test_voidVariable_parseCompilationUnit_initializer() {
-    parseCompilationUnit("void x = 0;");
-  }
-
-  void test_voidVariable_parseCompilationUnit_noInitializer() {
-    parseCompilationUnit("void x;");
-  }
-
-  void test_voidVariable_parseCompilationUnitMember_initializer() {
-    createParser('void a = 0;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    assertNoErrors();
-  }
-
-  void test_voidVariable_parseCompilationUnitMember_noInitializer() {
-    createParser('void a;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(member);
-    assertNoErrors();
-  }
-
-  void test_voidVariable_statement_initializer() {
-    parseStatement("void x = 0;");
-    assertNoErrors();
-  }
-
-  void test_voidVariable_statement_noInitializer() {
-    parseStatement("void x;");
-    assertNoErrors();
-  }
-
-  void test_withBeforeExtends() {
-    parseCompilationUnit("class A with B extends C {}",
-        errors: [expectedError(ParserErrorCode.WITH_BEFORE_EXTENDS, 15, 7)]);
-  }
-
-  void test_withWithoutExtends() {
-    createParser('class A with B, C {}');
-    ClassDeclaration declaration = parseFullCompilationUnitMember();
-    expectNotNullIfNoErrors(declaration);
-    listener.assertNoErrors();
-  }
-
-  void test_wrongSeparatorForPositionalParameter() {
-    createParser('(a, [b : 0])');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    listener.assertErrors([
-      expectedError(
-          ParserErrorCode.WRONG_SEPARATOR_FOR_POSITIONAL_PARAMETER, 7, 1)
-    ]);
-  }
-
-  void test_wrongTerminatorForParameterGroup_named() {
-    createParser('(a, {b, c])');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    // fasta scanner generates '(a, {b, c]})' where '}' is synthetic
-    listener.assertErrors([
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 9, 1),
-      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 10, 1)
-    ]);
-  }
-
-  void test_wrongTerminatorForParameterGroup_optional() {
-    createParser('(a, [b, c})');
-    FormalParameterList list = parser.parseFormalParameterList();
-    expectNotNullIfNoErrors(list);
-    // fasta scanner generates '(a, [b, c}])' where ']' is synthetic
-    listener.assertErrors([
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 9, 1),
-      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 10, 1)
-    ]);
-  }
-
-  void test_yieldAsLabel() {
-    // yield can be used as a label
-    parseCompilationUnit('main() { yield: break yield; }');
-  }
-}
-
-/// Tests of the fasta parser based on [ExpressionParserTestMixin].
-@reflectiveTest
-class ExpressionParserTest extends FastaParserTestCase {
-  final beforeUiAsCode = FeatureSet.fromEnableFlags2(
-    sdkLanguageVersion: Version.parse('2.2.0'),
-    flags: [],
-  );
-
-  void test_binaryExpression_allOperators() {
-    // https://github.com/dart-lang/sdk/issues/36255
-    for (TokenType type in TokenType.all) {
-      if (type.precedence > 0) {
-        var source = 'a ${type.lexeme} b';
-        try {
-          parseExpression(source);
-        } on TestFailure {
-          // Ensure that there are no infinite loops or exceptions thrown
-          // by the parser. Test failures are fine.
-        }
-      }
-    }
-  }
-
-  void test_invalidExpression_37706() {
-    // https://github.com/dart-lang/sdk/issues/37706
-    parseExpression('<b?c>()', errors: [
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 1, 1),
-      expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 7, 0),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 7, 0),
-    ]);
-  }
-
-  void test_listLiteral_invalid_assert() {
-    // https://github.com/dart-lang/sdk/issues/37674
-    parseExpression('n=<.["\$assert', errors: [
-      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 3, 1),
-      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 4, 1),
-      expectedError(ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD, 7, 6),
-      expectedError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 12, 1),
-      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 13, 1),
-    ]);
-  }
-
-  void test_listLiteral_invalidElement_37697() {
-    // https://github.com/dart-lang/sdk/issues/37674
-    parseExpression('[<y.<z>(){}]', errors: [
-      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 4, 1),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 6, 1),
-    ]);
-  }
-
-  void test_lt_dot_bracket_quote() {
-    // https://github.com/dart-lang/sdk/issues/37674
-    var list = parseExpression('<.["', errors: [
-      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 1, 1),
-      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 2, 1),
-      expectedError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 3, 1),
-      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 4, 1),
-    ]) as ListLiteral;
-    expect(list.elements, hasLength(1));
-    var first = list.elements[0] as StringLiteral;
-    expect(first.length, 1);
-  }
-
-  void test_lt_dot_listLiteral() {
-    // https://github.com/dart-lang/sdk/issues/37674
-    var list = parseExpression('<.[]', errors: [
-      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 1, 1),
-      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 2, 2),
-    ]) as ListLiteral;
-    expect(list.elements, hasLength(0));
-  }
-
-  void test_mapLiteral() {
-    var map = parseExpression('{3: 6}') as SetOrMapLiteral;
-    expect(map.constKeyword, isNull);
-    expect(map.typeArguments, isNull);
-    expect(map.elements, hasLength(1));
-    var entry = map.elements[0] as MapLiteralEntry;
-    var key = entry.key as IntegerLiteral;
-    expect(key.value, 3);
-    var value = entry.value as IntegerLiteral;
-    expect(value.value, 6);
-  }
-
-  void test_mapLiteral_const() {
-    var map = parseExpression('const {3: 6}') as SetOrMapLiteral;
-    expect(map.constKeyword, isNotNull);
-    expect(map.typeArguments, isNull);
-    expect(map.elements, hasLength(1));
-    var entry = map.elements[0] as MapLiteralEntry;
-    var key = entry.key as IntegerLiteral;
-    expect(key.value, 3);
-    var value = entry.value as IntegerLiteral;
-    expect(value.value, 6);
-  }
-
-  @failingTest
-  void test_mapLiteral_invalid_too_many_type_arguments1() {
-    var map = parseExpression('<int, int, int>{}', errors: [
-      // TODO(danrubel): Currently the resolver reports invalid number of
-      // type arguments, but the parser could report this.
-      expectedError(
-          /* ParserErrorCode.EXPECTED_ONE_OR_TWO_TYPE_VARIABLES */
-          ParserErrorCode.EXPECTED_TOKEN,
-          11,
-          3),
-    ]) as SetOrMapLiteral;
-    expect(map.constKeyword, isNull);
-    expect(map.elements, hasLength(0));
-  }
-
-  @failingTest
-  void test_mapLiteral_invalid_too_many_type_arguments2() {
-    var map = parseExpression('<int, int, int>{1}', errors: [
-      // TODO(danrubel): Currently the resolver reports invalid number of
-      // type arguments, but the parser could report this.
-      expectedError(
-          /* ParserErrorCode.EXPECTED_ONE_OR_TWO_TYPE_VARIABLES */
-          ParserErrorCode.EXPECTED_TOKEN,
-          11,
-          3),
-    ]) as SetOrMapLiteral;
-    expect(map.constKeyword, isNull);
-    expect(map.elements, hasLength(0));
-  }
-
-  void test_parseConstructorInitializer_functionExpression() {
-    // https://github.com/dart-lang/sdk/issues/37414
-    parseCompilationUnit('class C { C.n() : this()(); }', errors: [
-      expectedError(ParserErrorCode.INVALID_INITIALIZER, 18, 8),
-    ]);
-  }
-
-  void test_parseStringLiteral_interpolated_void() {
-    Expression expression = parseStringLiteral(r"'<html>$void</html>'");
-    expect(expression, isNotNull);
-    assertErrors(errors: [
-      expectedError(ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD, 8, 4)
-    ]);
-    expect(expression, isStringInterpolation);
-    var literal = expression as StringInterpolation;
-    NodeList<InterpolationElement> elements = literal.elements;
-    expect(elements, hasLength(3));
-    expect(elements[0] is InterpolationString, isTrue);
-    expect(elements[1] is InterpolationExpression, isTrue);
-    expect(elements[2] is InterpolationString, isTrue);
-    expect((elements[1] as InterpolationExpression).leftBracket.lexeme, '\$');
-    expect((elements[1] as InterpolationExpression).rightBracket, isNull);
-  }
-
-  @failingTest
-  void test_parseUnaryExpression_decrement_super() {
-    // TODO(danrubel) Reports a different error and different token stream.
-    // Expected: TokenType:<MINUS>
-    //   Actual: TokenType:<MINUS_MINUS>
-    PrefixExpression expression = parseUnaryExpression('--super');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.MINUS);
-    Expression innerExpression = expression.operand;
-    expect(innerExpression, isNotNull);
-    expect(innerExpression is PrefixExpression, isTrue);
-    PrefixExpression operand = innerExpression as PrefixExpression;
-    expect(operand.operator, isNotNull);
-    expect(operand.operator.type, TokenType.MINUS);
-    expect(operand.operand, isNotNull);
-  }
-
-  @failingTest
-  void test_parseUnaryExpression_decrement_super_withComment() {
-    // TODO(danrubel) Reports a different error and different token stream.
-    // Expected: TokenType:<MINUS>
-    //   Actual: TokenType:<MINUS_MINUS>
-
-    PrefixExpression expression = parseUnaryExpression('/* 0 */ --super');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.MINUS);
-    expect(expression.operator.precedingComments, isNotNull);
-    Expression innerExpression = expression.operand;
-    expect(innerExpression, isNotNull);
-    expect(innerExpression is PrefixExpression, isTrue);
-    PrefixExpression operand = innerExpression as PrefixExpression;
-    expect(operand.operator, isNotNull);
-    expect(operand.operator.type, TokenType.MINUS);
-    expect(operand.operand, isNotNull);
-  }
-
-  void test_setLiteral() {
-    SetOrMapLiteral set = parseExpression('{3}');
-    expect(set.constKeyword, isNull);
-    expect(set.typeArguments, isNull);
-    expect(set.elements, hasLength(1));
-    IntegerLiteral value = set.elements[0];
-    expect(value.value, 3);
-  }
-
-  void test_setLiteral_const() {
-    SetOrMapLiteral set = parseExpression('const {3, 6}');
-    expect(set.constKeyword, isNotNull);
-    expect(set.typeArguments, isNull);
-    expect(set.elements, hasLength(2));
-    IntegerLiteral value1 = set.elements[0];
-    expect(value1.value, 3);
-    IntegerLiteral value2 = set.elements[1];
-    expect(value2.value, 6);
-  }
-
-  void test_setLiteral_const_typed() {
-    SetOrMapLiteral set = parseExpression('const <int>{3}');
-    expect(set.constKeyword, isNotNull);
-    expect(set.typeArguments.arguments, hasLength(1));
-    NamedType typeArg = set.typeArguments.arguments[0];
-    expect(typeArg.name.name, 'int');
-    expect(set.elements.length, 1);
-    IntegerLiteral value = set.elements[0];
-    expect(value.value, 3);
-  }
-
-  void test_setLiteral_nested_typeArgument() {
-    SetOrMapLiteral set = parseExpression('<Set<int>>{{3}}');
-    expect(set.constKeyword, isNull);
-    expect(set.typeArguments.arguments, hasLength(1));
-    NamedType typeArg1 = set.typeArguments.arguments[0];
-    expect(typeArg1.name.name, 'Set');
-    expect(typeArg1.typeArguments.arguments, hasLength(1));
-    NamedType typeArg2 = typeArg1.typeArguments.arguments[0];
-    expect(typeArg2.name.name, 'int');
-    expect(set.elements.length, 1);
-    SetOrMapLiteral intSet = set.elements[0];
-    expect(intSet.elements, hasLength(1));
-    IntegerLiteral value = intSet.elements[0];
-    expect(value.value, 3);
-  }
-
-  void test_setLiteral_typed() {
-    SetOrMapLiteral set = parseExpression('<int>{3}');
-    expect(set.constKeyword, isNull);
-    expect(set.typeArguments.arguments, hasLength(1));
-    NamedType typeArg = set.typeArguments.arguments[0];
-    expect(typeArg.name.name, 'int');
-    expect(set.elements.length, 1);
-    IntegerLiteral value = set.elements[0];
-    expect(value.value, 3);
-  }
-}
-
-mixin ExpressionParserTestMixin implements AbstractParserTestCase {
-  void test_namedArgument() {
-    var invocation = parseExpression('m(a: 1, b: 2)') as MethodInvocation;
-    List<Expression> arguments = invocation.argumentList.arguments;
-
-    var a = arguments[0] as NamedExpression;
-    expect(a.name.label.name, 'a');
-    expect(a.expression, isNotNull);
-
-    var b = arguments[1] as NamedExpression;
-    expect(b.name.label.name, 'b');
-    expect(b.expression, isNotNull);
-  }
-
-  void test_parseAdditiveExpression_normal() {
-    Expression expression = parseAdditiveExpression('x + y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, isNotNull);
-    expect(binaryExpression.operator, isNotNull);
-    expect(binaryExpression.operator.type, TokenType.PLUS);
-    expect(binaryExpression.rightOperand, isNotNull);
-  }
-
-  void test_parseAdditiveExpression_super() {
-    Expression expression = parseAdditiveExpression('super + y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, isSuperExpression);
-    expect(binaryExpression.operator, isNotNull);
-    expect(binaryExpression.operator.type, TokenType.PLUS);
-    expect(binaryExpression.rightOperand, isNotNull);
-  }
-
-  void test_parseAssignableExpression_expression_args_dot() {
-    Expression expression = parseAssignableExpression('(x)(y).z', false);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var propertyAccess = expression as PropertyAccess;
-    FunctionExpressionInvocation invocation =
-        propertyAccess.target as FunctionExpressionInvocation;
-    expect(invocation.function, isNotNull);
-    expect(invocation.typeArguments, isNull);
-    ArgumentList argumentList = invocation.argumentList;
-    expect(argumentList, isNotNull);
-    expect(argumentList.arguments, hasLength(1));
-    expect(propertyAccess.operator, isNotNull);
-    expect(propertyAccess.propertyName, isNotNull);
-  }
-
-  void test_parseAssignableExpression_expression_args_dot_typeArguments() {
-    Expression expression = parseAssignableExpression('(x)<F>(y).z', false);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var propertyAccess = expression as PropertyAccess;
-    FunctionExpressionInvocation invocation =
-        propertyAccess.target as FunctionExpressionInvocation;
-    expect(invocation.function, isNotNull);
-    expect(invocation.typeArguments, isNotNull);
-    ArgumentList argumentList = invocation.argumentList;
-    expect(argumentList, isNotNull);
-    expect(argumentList.arguments, hasLength(1));
-    expect(propertyAccess.operator, isNotNull);
-    expect(propertyAccess.propertyName, isNotNull);
-  }
-
-  void test_parseAssignableExpression_expression_dot() {
-    Expression expression = parseAssignableExpression('(x).y', false);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var propertyAccess = expression as PropertyAccess;
-    expect(propertyAccess.target, isNotNull);
-    expect(propertyAccess.operator.type, TokenType.PERIOD);
-    expect(propertyAccess.propertyName, isNotNull);
-  }
-
-  void test_parseAssignableExpression_expression_index() {
-    Expression expression = parseAssignableExpression('(x)[y]', false);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var indexExpression = expression as IndexExpression;
-    expect(indexExpression.target, isNotNull);
-    expect(indexExpression.leftBracket, isNotNull);
-    expect(indexExpression.index, isNotNull);
-    expect(indexExpression.rightBracket, isNotNull);
-  }
-
-  void test_parseAssignableExpression_expression_question_dot() {
-    Expression expression = parseAssignableExpression('(x)?.y', false);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var propertyAccess = expression as PropertyAccess;
-    expect(propertyAccess.target, isNotNull);
-    expect(propertyAccess.operator.type, TokenType.QUESTION_PERIOD);
-    expect(propertyAccess.propertyName, isNotNull);
-  }
-
-  void test_parseAssignableExpression_identifier() {
-    Expression expression = parseAssignableExpression('x', false);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var identifier = expression as SimpleIdentifier;
-    expect(identifier, isNotNull);
-  }
-
-  void test_parseAssignableExpression_identifier_args_dot() {
-    Expression expression = parseAssignableExpression('x(y).z', false);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var propertyAccess = expression as PropertyAccess;
-    MethodInvocation invocation = propertyAccess.target as MethodInvocation;
-    expect(invocation.methodName.name, "x");
-    expect(invocation.typeArguments, isNull);
-    ArgumentList argumentList = invocation.argumentList;
-    expect(argumentList, isNotNull);
-    expect(argumentList.arguments, hasLength(1));
-    expect(propertyAccess.operator, isNotNull);
-    expect(propertyAccess.propertyName, isNotNull);
-  }
-
-  void test_parseAssignableExpression_identifier_args_dot_typeArguments() {
-    Expression expression = parseAssignableExpression('x<E>(y).z', false);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var propertyAccess = expression as PropertyAccess;
-    MethodInvocation invocation = propertyAccess.target as MethodInvocation;
-    expect(invocation.methodName.name, "x");
-    expect(invocation.typeArguments, isNotNull);
-    ArgumentList argumentList = invocation.argumentList;
-    expect(argumentList, isNotNull);
-    expect(argumentList.arguments, hasLength(1));
-    expect(propertyAccess.operator, isNotNull);
-    expect(propertyAccess.propertyName, isNotNull);
-  }
-
-  void test_parseAssignableExpression_identifier_dot() {
-    Expression expression = parseAssignableExpression('x.y', false);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var identifier = expression as PrefixedIdentifier;
-    expect(identifier.prefix.name, 'x');
-    expect(identifier.period, isNotNull);
-    expect(identifier.period.type, TokenType.PERIOD);
-    expect(identifier.identifier.name, 'y');
-  }
-
-  void test_parseAssignableExpression_identifier_index() {
-    Expression expression = parseAssignableExpression('x[y]', false);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var indexExpression = expression as IndexExpression;
-    expect(indexExpression.target, isNotNull);
-    expect(indexExpression.leftBracket, isNotNull);
-    expect(indexExpression.index, isNotNull);
-    expect(indexExpression.rightBracket, isNotNull);
-  }
-
-  void test_parseAssignableExpression_identifier_question_dot() {
-    Expression expression = parseAssignableExpression('x?.y', false);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var propertyAccess = expression as PropertyAccess;
-    expect(propertyAccess.target, isNotNull);
-    expect(propertyAccess.operator.type, TokenType.QUESTION_PERIOD);
-    expect(propertyAccess.propertyName, isNotNull);
-  }
-
-  void test_parseAssignableExpression_super_dot() {
-    Expression expression = parseAssignableExpression('super.y', false);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var propertyAccess = expression as PropertyAccess;
-    expect(propertyAccess.target, isSuperExpression);
-    expect(propertyAccess.operator, isNotNull);
-    expect(propertyAccess.propertyName, isNotNull);
-  }
-
-  void test_parseAssignableExpression_super_index() {
-    Expression expression = parseAssignableExpression('super[y]', false);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var indexExpression = expression as IndexExpression;
-    expect(indexExpression.target, isSuperExpression);
-    expect(indexExpression.leftBracket, isNotNull);
-    expect(indexExpression.index, isNotNull);
-    expect(indexExpression.rightBracket, isNotNull);
-  }
-
-  void test_parseAssignableSelector_dot() {
-    Expression expression = parseAssignableSelector('.x', true);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var propertyAccess = expression as PropertyAccess;
-    expect(propertyAccess.operator.type, TokenType.PERIOD);
-    expect(propertyAccess.propertyName, isNotNull);
-  }
-
-  void test_parseAssignableSelector_index() {
-    Expression expression = parseAssignableSelector('[x]', true);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var indexExpression = expression as IndexExpression;
-    expect(indexExpression.leftBracket, isNotNull);
-    expect(indexExpression.index, isNotNull);
-    expect(indexExpression.rightBracket, isNotNull);
-  }
-
-  void test_parseAssignableSelector_none() {
-    Expression expression = parseAssignableSelector('', true);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var identifier = expression as SimpleIdentifier;
-    expect(identifier, isNotNull);
-  }
-
-  void test_parseAssignableSelector_question_dot() {
-    Expression expression = parseAssignableSelector('?.x', true);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var propertyAccess = expression as PropertyAccess;
-    expect(propertyAccess.operator.type, TokenType.QUESTION_PERIOD);
-    expect(propertyAccess.propertyName, isNotNull);
-  }
-
-  void test_parseAwaitExpression() {
-    AwaitExpression expression = parseAwaitExpression('await x');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.awaitKeyword, isNotNull);
-    expect(expression.expression, isNotNull);
-  }
-
-  void test_parseBitwiseAndExpression_normal() {
-    Expression expression = parseBitwiseAndExpression('x & y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, isNotNull);
-    expect(binaryExpression.operator, isNotNull);
-    expect(binaryExpression.operator.type, TokenType.AMPERSAND);
-    expect(binaryExpression.rightOperand, isNotNull);
-  }
-
-  void test_parseBitwiseAndExpression_super() {
-    Expression expression = parseBitwiseAndExpression('super & y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, isSuperExpression);
-    expect(binaryExpression.operator, isNotNull);
-    expect(binaryExpression.operator.type, TokenType.AMPERSAND);
-    expect(binaryExpression.rightOperand, isNotNull);
-  }
-
-  void test_parseBitwiseOrExpression_normal() {
-    Expression expression = parseBitwiseOrExpression('x | y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, isNotNull);
-    expect(binaryExpression.operator, isNotNull);
-    expect(binaryExpression.operator.type, TokenType.BAR);
-    expect(binaryExpression.rightOperand, isNotNull);
-  }
-
-  void test_parseBitwiseOrExpression_super() {
-    Expression expression = parseBitwiseOrExpression('super | y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, isSuperExpression);
-    expect(binaryExpression.operator, isNotNull);
-    expect(binaryExpression.operator.type, TokenType.BAR);
-    expect(binaryExpression.rightOperand, isNotNull);
-  }
-
-  void test_parseBitwiseXorExpression_normal() {
-    Expression expression = parseBitwiseXorExpression('x ^ y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, isNotNull);
-    expect(binaryExpression.operator, isNotNull);
-    expect(binaryExpression.operator.type, TokenType.CARET);
-    expect(binaryExpression.rightOperand, isNotNull);
-  }
-
-  void test_parseBitwiseXorExpression_super() {
-    Expression expression = parseBitwiseXorExpression('super ^ y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, isSuperExpression);
-    expect(binaryExpression.operator, isNotNull);
-    expect(binaryExpression.operator.type, TokenType.CARET);
-    expect(binaryExpression.rightOperand, isNotNull);
-  }
-
-  void test_parseCascadeSection_i() {
-    Expression expression = parseCascadeSection('..[i]');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var section = expression as IndexExpression;
-    expect(section.target, isNull);
-    expect(section.leftBracket, isNotNull);
-    expect(section.index, isNotNull);
-    expect(section.rightBracket, isNotNull);
-  }
-
-  void test_parseCascadeSection_ia() {
-    Expression expression = parseCascadeSection('..[i](b)');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var section = expression as FunctionExpressionInvocation;
-    expect(section.function, isIndexExpression);
-    expect(section.typeArguments, isNull);
-    expect(section.argumentList, isNotNull);
-  }
-
-  void test_parseCascadeSection_ia_typeArguments() {
-    Expression expression = parseCascadeSection('..[i]<E>(b)');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var section = expression as FunctionExpressionInvocation;
-    expect(section.function, isIndexExpression);
-    expect(section.typeArguments, isNotNull);
-    expect(section.argumentList, isNotNull);
-  }
-
-  void test_parseCascadeSection_ii() {
-    Expression expression = parseCascadeSection('..a(b).c(d)');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var section = expression as MethodInvocation;
-    expect(section.target, isMethodInvocation);
-    expect(section.operator, isNotNull);
-    expect(section.methodName, isNotNull);
-    expect(section.typeArguments, isNull);
-    expect(section.argumentList, isNotNull);
-    expect(section.argumentList.arguments, hasLength(1));
-  }
-
-  void test_parseCascadeSection_ii_typeArguments() {
-    Expression expression = parseCascadeSection('..a<E>(b).c<F>(d)');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var section = expression as MethodInvocation;
-    expect(section.target, isMethodInvocation);
-    expect(section.operator, isNotNull);
-    expect(section.methodName, isNotNull);
-    expect(section.typeArguments, isNotNull);
-    expect(section.argumentList, isNotNull);
-    expect(section.argumentList.arguments, hasLength(1));
-  }
-
-  void test_parseCascadeSection_p() {
-    Expression expression = parseCascadeSection('..a');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var section = expression as PropertyAccess;
-    expect(section.target, isNull);
-    expect(section.operator, isNotNull);
-    expect(section.propertyName, isNotNull);
-  }
-
-  void test_parseCascadeSection_p_assign() {
-    Expression expression = parseCascadeSection('..a = 3');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var section = expression as AssignmentExpression;
-    expect(section.leftHandSide, isNotNull);
-    expect(section.operator, isNotNull);
-    Expression rhs = section.rightHandSide;
-    expect(rhs, isNotNull);
-  }
-
-  void test_parseCascadeSection_p_assign_withCascade() {
-    Expression expression = parseCascadeSection('..a = 3..m()');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var section = expression as AssignmentExpression;
-    expect(section.leftHandSide, isNotNull);
-    expect(section.operator, isNotNull);
-    Expression rhs = section.rightHandSide;
-    expect(rhs, isIntegerLiteral);
-  }
-
-  void test_parseCascadeSection_p_assign_withCascade_typeArguments() {
-    Expression expression = parseCascadeSection('..a = 3..m<E>()');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var section = expression as AssignmentExpression;
-    expect(section.leftHandSide, isNotNull);
-    expect(section.operator, isNotNull);
-    Expression rhs = section.rightHandSide;
-    expect(rhs, isIntegerLiteral);
-  }
-
-  void test_parseCascadeSection_p_builtIn() {
-    Expression expression = parseCascadeSection('..as');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var section = expression as PropertyAccess;
-    expect(section.target, isNull);
-    expect(section.operator, isNotNull);
-    expect(section.propertyName, isNotNull);
-  }
-
-  void test_parseCascadeSection_pa() {
-    Expression expression = parseCascadeSection('..a(b)');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var section = expression as MethodInvocation;
-    expect(section.target, isNull);
-    expect(section.operator, isNotNull);
-    expect(section.methodName, isNotNull);
-    expect(section.typeArguments, isNull);
-    expect(section.argumentList, isNotNull);
-    expect(section.argumentList.arguments, hasLength(1));
-  }
-
-  void test_parseCascadeSection_pa_typeArguments() {
-    Expression expression = parseCascadeSection('..a<E>(b)');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var section = expression as MethodInvocation;
-    expect(section.target, isNull);
-    expect(section.operator, isNotNull);
-    expect(section.methodName, isNotNull);
-    expect(section.typeArguments, isNotNull);
-    expect(section.argumentList, isNotNull);
-    expect(section.argumentList.arguments, hasLength(1));
-  }
-
-  void test_parseCascadeSection_paa() {
-    Expression expression = parseCascadeSection('..a(b)(c)');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var section = expression as FunctionExpressionInvocation;
-    expect(section.function, isMethodInvocation);
-    expect(section.typeArguments, isNull);
-    expect(section.argumentList, isNotNull);
-    expect(section.argumentList.arguments, hasLength(1));
-  }
-
-  void test_parseCascadeSection_paa_typeArguments() {
-    Expression expression = parseCascadeSection('..a<E>(b)<F>(c)');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var section = expression as FunctionExpressionInvocation;
-    expect(section.function, isMethodInvocation);
-    expect(section.typeArguments, isNotNull);
-    expect(section.argumentList, isNotNull);
-    expect(section.argumentList.arguments, hasLength(1));
-  }
-
-  void test_parseCascadeSection_paapaa() {
-    Expression expression = parseCascadeSection('..a(b)(c).d(e)(f)');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var section = expression as FunctionExpressionInvocation;
-    expect(section.function, isMethodInvocation);
-    expect(section.typeArguments, isNull);
-    expect(section.argumentList, isNotNull);
-    expect(section.argumentList.arguments, hasLength(1));
-  }
-
-  void test_parseCascadeSection_paapaa_typeArguments() {
-    Expression expression =
-        parseCascadeSection('..a<E>(b)<F>(c).d<G>(e)<H>(f)');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var section = expression as FunctionExpressionInvocation;
-    expect(section.function, isMethodInvocation);
-    expect(section.typeArguments, isNotNull);
-    expect(section.argumentList, isNotNull);
-    expect(section.argumentList.arguments, hasLength(1));
-  }
-
-  void test_parseCascadeSection_pap() {
-    Expression expression = parseCascadeSection('..a(b).c');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var section = expression as PropertyAccess;
-    expect(section.target, isNotNull);
-    expect(section.operator, isNotNull);
-    expect(section.propertyName, isNotNull);
-  }
-
-  void test_parseCascadeSection_pap_typeArguments() {
-    Expression expression = parseCascadeSection('..a<E>(b).c');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var section = expression as PropertyAccess;
-    expect(section.target, isNotNull);
-    expect(section.operator, isNotNull);
-    expect(section.propertyName, isNotNull);
-  }
-
-  void test_parseConditionalExpression() {
-    ConditionalExpression expression = parseConditionalExpression('x ? y : z');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.condition, isNotNull);
-    expect(expression.question, isNotNull);
-    expect(expression.thenExpression, isNotNull);
-    expect(expression.colon, isNotNull);
-    expect(expression.elseExpression, isNotNull);
-  }
-
-  void test_parseConstExpression_instanceCreation() {
-    Expression expression = parseConstExpression('const A()');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression, isInstanceCreationExpression);
-    InstanceCreationExpression instanceCreation = expression;
-    expect(instanceCreation.keyword, isNotNull);
-    ConstructorName name = instanceCreation.constructorName;
-    expect(name, isNotNull);
-    expect(name.type, isNotNull);
-    expect(name.period, isNull);
-    expect(name.name, isNull);
-    expect(instanceCreation.argumentList, isNotNull);
-  }
-
-  void test_parseConstExpression_listLiteral_typed() {
-    Expression expression = parseConstExpression('const <A> []');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as ListLiteral;
-    expect(literal.constKeyword, isNotNull);
-    expect(literal.typeArguments, isNotNull);
-    expect(literal.leftBracket, isNotNull);
-    expect(literal.elements, hasLength(0));
-    expect(literal.rightBracket, isNotNull);
-  }
-
-  void test_parseConstExpression_listLiteral_untyped() {
-    Expression expression = parseConstExpression('const []');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as ListLiteral;
-    expect(literal.constKeyword, isNotNull);
-    expect(literal.typeArguments, isNull);
-    expect(literal.leftBracket, isNotNull);
-    expect(literal.elements, hasLength(0));
-    expect(literal.rightBracket, isNotNull);
-  }
-
-  void test_parseConstExpression_mapLiteral_typed() {
-    Expression expression = parseConstExpression('const <A, B> {}');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as SetOrMapLiteral;
-    expect(literal.leftBracket, isNotNull);
-    expect(literal.elements, hasLength(0));
-    expect(literal.rightBracket, isNotNull);
-    expect(literal.typeArguments, isNotNull);
-  }
-
-  void test_parseConstExpression_mapLiteral_typed_missingGt() {
-    Expression expression = parseExpression('const <A, B {}',
-        errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 10, 1)]);
-    expect(expression, isNotNull);
-    var literal = expression as SetOrMapLiteral;
-    expect(literal.leftBracket, isNotNull);
-    expect(literal.elements, hasLength(0));
-    expect(literal.rightBracket, isNotNull);
-    expect(literal.typeArguments, isNotNull);
-  }
-
-  void test_parseConstExpression_mapLiteral_untyped() {
-    Expression expression = parseConstExpression('const {}');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as SetOrMapLiteral;
-    expect(literal.leftBracket, isNotNull);
-    expect(literal.elements, hasLength(0));
-    expect(literal.rightBracket, isNotNull);
-    expect(literal.typeArguments, isNull);
-  }
-
-  void test_parseEqualityExpression_normal() {
-    BinaryExpression expression = parseEqualityExpression('x == y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.leftOperand, isNotNull);
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.EQ_EQ);
-    expect(expression.rightOperand, isNotNull);
-  }
-
-  void test_parseEqualityExpression_super() {
-    BinaryExpression expression = parseEqualityExpression('super == y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.leftOperand, isSuperExpression);
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.EQ_EQ);
-    expect(expression.rightOperand, isNotNull);
-  }
-
-  void test_parseExpression_assign() {
-    // TODO(brianwilkerson) Implement more tests for this method.
-    Expression expression = parseExpression('x = y');
-    var assignmentExpression = expression as AssignmentExpression;
-    expect(assignmentExpression.leftHandSide, isNotNull);
-    expect(assignmentExpression.operator, isNotNull);
-    expect(assignmentExpression.operator.type, TokenType.EQ);
-    expect(assignmentExpression.rightHandSide, isNotNull);
-  }
-
-  void test_parseExpression_assign_compound() {
-    if (AbstractScanner.LAZY_ASSIGNMENT_ENABLED) {
-      Expression expression = parseExpression('x ||= y');
-      var assignmentExpression = expression as AssignmentExpression;
-      expect(assignmentExpression.leftHandSide, isNotNull);
-      expect(assignmentExpression.operator, isNotNull);
-      expect(assignmentExpression.operator.type, TokenType.BAR_BAR_EQ);
-      expect(assignmentExpression.rightHandSide, isNotNull);
-    }
-  }
-
-  void test_parseExpression_comparison() {
-    Expression expression = parseExpression('--a.b == c');
-    var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, isNotNull);
-    expect(binaryExpression.operator, isNotNull);
-    expect(binaryExpression.operator.type, TokenType.EQ_EQ);
-    expect(binaryExpression.rightOperand, isNotNull);
-  }
-
-  void test_parseExpression_constAndTypeParameters() {
-    Expression expression = parseExpression('const <E>', codes: [
-      // TODO(danrubel): Improve this error message.
-      ParserErrorCode.EXPECTED_TOKEN
-    ]);
-    expect(expression, isNotNull);
-  }
-
-  void test_parseExpression_function_async() {
-    Expression expression = parseExpression('() async {}');
-    var functionExpression = expression as FunctionExpression;
-    expect(functionExpression.body, isNotNull);
-    expect(functionExpression.body.isAsynchronous, isTrue);
-    expect(functionExpression.body.isGenerator, isFalse);
-    expect(functionExpression.parameters, isNotNull);
-  }
-
-  void test_parseExpression_function_asyncStar() {
-    Expression expression = parseExpression('() async* {}');
-    var functionExpression = expression as FunctionExpression;
-    expect(functionExpression.body, isNotNull);
-    expect(functionExpression.body.isAsynchronous, isTrue);
-    expect(functionExpression.body.isGenerator, isTrue);
-    expect(functionExpression.parameters, isNotNull);
-  }
-
-  void test_parseExpression_function_sync() {
-    Expression expression = parseExpression('() {}');
-    var functionExpression = expression as FunctionExpression;
-    expect(functionExpression.body, isNotNull);
-    expect(functionExpression.body.isAsynchronous, isFalse);
-    expect(functionExpression.body.isGenerator, isFalse);
-    expect(functionExpression.parameters, isNotNull);
-  }
-
-  void test_parseExpression_function_syncStar() {
-    Expression expression = parseExpression('() sync* {}');
-    var functionExpression = expression as FunctionExpression;
-    expect(functionExpression.body, isNotNull);
-    expect(functionExpression.body.isAsynchronous, isFalse);
-    expect(functionExpression.body.isGenerator, isTrue);
-    expect(functionExpression.parameters, isNotNull);
-  }
-
-  void test_parseExpression_invokeFunctionExpression() {
-    Expression expression = parseExpression('(a) {return a + a;} (3)');
-    var invocation = expression as FunctionExpressionInvocation;
-    expect(invocation.function, isFunctionExpression);
-    FunctionExpression functionExpression =
-        invocation.function as FunctionExpression;
-    expect(functionExpression.parameters, isNotNull);
-    expect(functionExpression.body, isNotNull);
-    expect(invocation.typeArguments, isNull);
-    ArgumentList list = invocation.argumentList;
-    expect(list, isNotNull);
-    expect(list.arguments, hasLength(1));
-  }
-
-  void test_parseExpression_nonAwait() {
-    Expression expression = parseExpression('await()');
-    var invocation = expression as MethodInvocation;
-    expect(invocation.methodName.name, 'await');
-    expect(invocation.typeArguments, isNull);
-    expect(invocation.argumentList, isNotNull);
-  }
-
-  void test_parseExpression_sendWithTypeParam_afterIndex() {
-    final unit = parseCompilationUnit('main() { factories[C]<num, int>(); }');
-    expect(unit.declarations, hasLength(1));
-    FunctionDeclaration mainMethod = unit.declarations[0];
-    BlockFunctionBody body = mainMethod.functionExpression.body;
-    NodeList<Statement> statements = body.block.statements;
-    expect(statements, hasLength(1));
-    ExpressionStatement statement = statements[0];
-    FunctionExpressionInvocation expression = statement.expression;
-
-    IndexExpression function = expression.function;
-    SimpleIdentifier target = function.target;
-    expect(target.name, 'factories');
-    SimpleIdentifier index = function.index;
-    expect(index.name, 'C');
-
-    NodeList<TypeAnnotation> typeArguments = expression.typeArguments.arguments;
-    expect(typeArguments, hasLength(2));
-    expect((typeArguments[0] as NamedType).name.name, 'num');
-    expect((typeArguments[1] as NamedType).name.name, 'int');
-
-    expect(expression.argumentList.arguments, hasLength(0));
-  }
-
-  void test_parseExpression_sendWithTypeParam_afterSend() {
-    final unit = parseCompilationUnit('main() { factories(C)<num, int>(); }');
-    expect(unit.declarations, hasLength(1));
-    FunctionDeclaration mainMethod = unit.declarations[0];
-    BlockFunctionBody body = mainMethod.functionExpression.body;
-    NodeList<Statement> statements = body.block.statements;
-    expect(statements, hasLength(1));
-    ExpressionStatement statement = statements[0];
-    FunctionExpressionInvocation expression = statement.expression;
-
-    MethodInvocation invocation = expression.function;
-    expect(invocation.methodName.name, 'factories');
-    NodeList<Expression> invocationArguments =
-        invocation.argumentList.arguments;
-    expect(invocationArguments, hasLength(1));
-    SimpleIdentifier index = invocationArguments[0];
-    expect(index.name, 'C');
-
-    NodeList<TypeAnnotation> typeArguments = expression.typeArguments.arguments;
-    expect(typeArguments, hasLength(2));
-    expect((typeArguments[0] as NamedType).name.name, 'num');
-    expect((typeArguments[1] as NamedType).name.name, 'int');
-
-    expect(expression.argumentList.arguments, hasLength(0));
-  }
-
-  void test_parseExpression_superMethodInvocation() {
-    Expression expression = parseExpression('super.m()');
-    var invocation = expression as MethodInvocation;
-    expect(invocation.target, isNotNull);
-    expect(invocation.methodName, isNotNull);
-    expect(invocation.typeArguments, isNull);
-    expect(invocation.argumentList, isNotNull);
-  }
-
-  void test_parseExpression_superMethodInvocation_typeArguments() {
-    Expression expression = parseExpression('super.m<E>()');
-    var invocation = expression as MethodInvocation;
-    expect(invocation.target, isNotNull);
-    expect(invocation.methodName, isNotNull);
-    expect(invocation.typeArguments, isNotNull);
-    expect(invocation.argumentList, isNotNull);
-  }
-
-  void test_parseExpression_superMethodInvocation_typeArguments_chained() {
-    Expression expression = parseExpression('super.b.c<D>()');
-    MethodInvocation invocation = expression as MethodInvocation;
-    Expression target = invocation.target;
-    expect(target, isPropertyAccess);
-    expect(invocation.methodName, isNotNull);
-    expect(invocation.methodName.name, 'c');
-    expect(invocation.typeArguments, isNotNull);
-    expect(invocation.argumentList, isNotNull);
-  }
-
-  void test_parseExpressionList_multiple() {
-    List<Expression> result = parseExpressionList('1, 2, 3');
-    expect(result, isNotNull);
-    assertNoErrors();
-    expect(result, hasLength(3));
-  }
-
-  void test_parseExpressionList_single() {
-    List<Expression> result = parseExpressionList('1');
-    expect(result, isNotNull);
-    assertNoErrors();
-    expect(result, hasLength(1));
-  }
-
-  void test_parseExpressionWithoutCascade_assign() {
-    // TODO(brianwilkerson) Implement more tests for this method.
-    Expression expression = parseExpressionWithoutCascade('x = y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var assignmentExpression = expression as AssignmentExpression;
-    expect(assignmentExpression.leftHandSide, isNotNull);
-    expect(assignmentExpression.operator, isNotNull);
-    expect(assignmentExpression.operator.type, TokenType.EQ);
-    expect(assignmentExpression.rightHandSide, isNotNull);
-  }
-
-  void test_parseExpressionWithoutCascade_comparison() {
-    Expression expression = parseExpressionWithoutCascade('--a.b == c');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, isNotNull);
-    expect(binaryExpression.operator, isNotNull);
-    expect(binaryExpression.operator.type, TokenType.EQ_EQ);
-    expect(binaryExpression.rightOperand, isNotNull);
-  }
-
-  void test_parseExpressionWithoutCascade_superMethodInvocation() {
-    Expression expression = parseExpressionWithoutCascade('super.m()');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var invocation = expression as MethodInvocation;
-    expect(invocation.target, isNotNull);
-    expect(invocation.methodName, isNotNull);
-    expect(invocation.typeArguments, isNull);
-    expect(invocation.argumentList, isNotNull);
-  }
-
-  void
-      test_parseExpressionWithoutCascade_superMethodInvocation_typeArguments() {
-    Expression expression = parseExpressionWithoutCascade('super.m<E>()');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var invocation = expression as MethodInvocation;
-    expect(invocation.target, isNotNull);
-    expect(invocation.methodName, isNotNull);
-    expect(invocation.typeArguments, isNotNull);
-    expect(invocation.argumentList, isNotNull);
-  }
-
-  void test_parseFunctionExpression_body_inExpression() {
-    FunctionExpression expression = parseFunctionExpression('(int i) => i++');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.body, isNotNull);
-    expect(expression.typeParameters, isNull);
-    expect(expression.parameters, isNotNull);
-    expect((expression.body as ExpressionFunctionBody).semicolon, isNull);
-  }
-
-  void test_parseFunctionExpression_constAndTypeParameters2() {
-    FunctionExpression expression =
-        parseFunctionExpression('const <E>(E i) => i++');
-    expect(expression, isNotNull);
-    assertErrorsWithCodes([ParserErrorCode.UNEXPECTED_TOKEN]);
-    expect(expression.body, isNotNull);
-    expect(expression.typeParameters, isNotNull);
-    expect(expression.parameters, isNotNull);
-    expect((expression.body as ExpressionFunctionBody).semicolon, isNull);
-  }
-
-  void test_parseFunctionExpression_functionInPlaceOfTypeName() {
-    Expression expression = parseExpression('<test(' ', (){});>[0, 1, 2]',
-        codes: [ParserErrorCode.EXPECTED_TOKEN]);
-    expect(expression, isNotNull);
-    ListLiteral literal = expression;
-    expect(literal.typeArguments.arguments, hasLength(1));
-  }
-
-  void test_parseFunctionExpression_typeParameters() {
-    FunctionExpression expression = parseFunctionExpression('<E>(E i) => i++');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.body, isNotNull);
-    expect(expression.typeParameters, isNotNull);
-    expect(expression.parameters, isNotNull);
-    expect((expression.body as ExpressionFunctionBody).semicolon, isNull);
-  }
-
-  void test_parseInstanceCreationExpression_qualifiedType() {
-    Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    InstanceCreationExpression expression =
-        parseInstanceCreationExpression('A.B()', token);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.keyword.keyword, Keyword.NEW);
-    ConstructorName name = expression.constructorName;
-    expect(name, isNotNull);
-    TypeName type = name.type;
-    expect(type.name.name, 'A.B');
-    expect(type.typeArguments, isNull);
-    expect(name.period, isNull);
-    expect(name.name, isNull);
-    expect(expression.argumentList, isNotNull);
-  }
-
-  void test_parseInstanceCreationExpression_qualifiedType_named() {
-    Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    InstanceCreationExpression expression =
-        parseInstanceCreationExpression('A.B.c()', token);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.keyword.keyword, Keyword.NEW);
-    ConstructorName name = expression.constructorName;
-    expect(name, isNotNull);
-    TypeName type = name.type;
-    expect(type, isNotNull);
-    expect(type.typeArguments, isNull);
-    expect(name.period, isNotNull);
-    expect(name.name, isNotNull);
-    expect(expression.argumentList, isNotNull);
-  }
-
-  void
-      test_parseInstanceCreationExpression_qualifiedType_named_typeArguments() {
-    Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    InstanceCreationExpression expression =
-        parseInstanceCreationExpression('A.B<E>.c()', token);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.keyword.keyword, Keyword.NEW);
-    ConstructorName name = expression.constructorName;
-    expect(name, isNotNull);
-    TypeName type = name.type;
-    expect(type, isNotNull);
-    expect(type.typeArguments.arguments, hasLength(1));
-    expect(name.period, isNotNull);
-    expect(name.name, isNotNull);
-    expect(expression.argumentList, isNotNull);
-  }
-
-  void test_parseInstanceCreationExpression_qualifiedType_typeArguments() {
-    Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    InstanceCreationExpression expression =
-        parseInstanceCreationExpression('A.B<E>()', token);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.keyword.keyword, Keyword.NEW);
-    ConstructorName name = expression.constructorName;
-    expect(name, isNotNull);
-    TypeName type = name.type;
-    expect(type, isNotNull);
-    expect(type.typeArguments.arguments, hasLength(1));
-    expect(name.period, isNull);
-    expect(name.name, isNull);
-    expect(expression.argumentList, isNotNull);
-  }
-
-  void test_parseInstanceCreationExpression_type() {
-    Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    InstanceCreationExpression expression =
-        parseInstanceCreationExpression('A()', token);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.keyword.keyword, Keyword.NEW);
-    ConstructorName name = expression.constructorName;
-    expect(name, isNotNull);
-    TypeName type = name.type;
-    expect(type, isNotNull);
-    expect(type.typeArguments, isNull);
-    expect(name.period, isNull);
-    expect(name.name, isNull);
-    expect(expression.argumentList, isNotNull);
-  }
-
-  void test_parseInstanceCreationExpression_type_named() {
-    Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    InstanceCreationExpression expression =
-        parseInstanceCreationExpression('A.c()', token);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.keyword.keyword, Keyword.NEW);
-    ConstructorName name = expression.constructorName;
-    expect(name, isNotNull);
-    TypeName type = name.type;
-    expect(type, isNotNull);
-    expect(type.typeArguments, isNull);
-    expect(name.period, isNull);
-    expect(name.name, isNull);
-    expect(expression.argumentList, isNotNull);
-  }
-
-  void test_parseInstanceCreationExpression_type_named_typeArguments() {
-    Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    InstanceCreationExpressionImpl expression =
-        parseInstanceCreationExpression('A<B>.c()', token);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.keyword.keyword, Keyword.NEW);
-    ConstructorName name = expression.constructorName;
-    expect(name, isNotNull);
-    TypeName type = name.type;
-    expect(type, isNotNull);
-    expect(type.typeArguments.arguments, hasLength(1));
-    expect(name.period, isNotNull);
-    expect(name.name, isNotNull);
-    expect(expression.argumentList, isNotNull);
-    expect(expression.typeArguments, isNull);
-  }
-
-  void test_parseInstanceCreationExpression_type_named_typeArguments_34403() {
-    InstanceCreationExpressionImpl expression =
-        parseExpression('new a.b.c<C>()', errors: [
-      expectedError(
-          CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_CONSTRUCTOR, 8, 1)
-    ]);
-    expect(expression, isNotNull);
-    expect(expression.keyword.keyword, Keyword.NEW);
-    ConstructorName name = expression.constructorName;
-    expect(name, isNotNull);
-    TypeName type = name.type;
-    expect(type, isNotNull);
-    expect(type.typeArguments, isNull);
-    expect(name.period, isNotNull);
-    expect(name.name, isNotNull);
-    expect(expression.argumentList, isNotNull);
-    expect(expression.typeArguments.arguments, hasLength(1));
-  }
-
-  void test_parseInstanceCreationExpression_type_typeArguments() {
-    Token token = TokenFactory.tokenFromKeyword(Keyword.NEW);
-    InstanceCreationExpression expression =
-        parseInstanceCreationExpression('A<B>()', token);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.keyword.keyword, Keyword.NEW);
-    ConstructorName name = expression.constructorName;
-    expect(name, isNotNull);
-    TypeName type = name.type;
-    expect(type, isNotNull);
-    expect(type.typeArguments.arguments, hasLength(1));
-    expect(name.period, isNull);
-    expect(name.name, isNull);
-    expect(expression.argumentList, isNotNull);
-  }
-
-  void test_parseListLiteral_empty_oneToken() {
-    Token token = TokenFactory.tokenFromKeyword(Keyword.CONST);
-    ListLiteral literal = parseListLiteral(token, null, '[]');
-    expect(literal, isNotNull);
-    assertNoErrors();
-    expect(literal.constKeyword.keyword, Keyword.CONST);
-    expect(literal.typeArguments, isNull);
-    expect(literal.leftBracket, isNotNull);
-    expect(literal.elements, hasLength(0));
-    expect(literal.rightBracket, isNotNull);
-  }
-
-  void test_parseListLiteral_empty_oneToken_withComment() {
-    ListLiteral literal = parseListLiteral(null, null, '/* 0 */ []');
-    expect(literal, isNotNull);
-    assertNoErrors();
-    expect(literal.constKeyword, isNull);
-    expect(literal.typeArguments, isNull);
-    Token leftBracket = literal.leftBracket;
-    expect(leftBracket, isNotNull);
-    expect(leftBracket.precedingComments, isNotNull);
-    expect(literal.elements, hasLength(0));
-    expect(literal.rightBracket, isNotNull);
-  }
-
-  void test_parseListLiteral_empty_twoTokens() {
-    Token token = TokenFactory.tokenFromKeyword(Keyword.CONST);
-    ListLiteral literal = parseListLiteral(token, null, '[ ]');
-    expect(literal, isNotNull);
-    assertNoErrors();
-    expect(literal.constKeyword.keyword, Keyword.CONST);
-    expect(literal.typeArguments, isNull);
-    expect(literal.leftBracket, isNotNull);
-    expect(literal.elements, hasLength(0));
-    expect(literal.rightBracket, isNotNull);
-  }
-
-  void test_parseListLiteral_multiple() {
-    ListLiteral literal = parseListLiteral(null, null, '[1, 2, 3]');
-    expect(literal, isNotNull);
-    assertNoErrors();
-    expect(literal.constKeyword, isNull);
-    expect(literal.typeArguments, isNull);
-    expect(literal.leftBracket, isNotNull);
-    expect(literal.elements, hasLength(3));
-    expect(literal.rightBracket, isNotNull);
-  }
-
-  void test_parseListLiteral_single() {
-    ListLiteral literal = parseListLiteral(null, null, '[1]');
-    expect(literal, isNotNull);
-    assertNoErrors();
-    expect(literal.constKeyword, isNull);
-    expect(literal.typeArguments, isNull);
-    expect(literal.leftBracket, isNotNull);
-    expect(literal.elements, hasLength(1));
-    expect(literal.rightBracket, isNotNull);
-  }
-
-  void test_parseListLiteral_single_withTypeArgument() {
-    ListLiteral literal = parseListLiteral(null, '<int>', '[1]');
-    expect(literal, isNotNull);
-    assertNoErrors();
-    expect(literal.constKeyword, isNull);
-    expect(literal.typeArguments, isNotNull);
-    expect(literal.leftBracket, isNotNull);
-    expect(literal.elements, hasLength(1));
-    expect(literal.rightBracket, isNotNull);
-  }
-
-  void test_parseListOrMapLiteral_list_noType() {
-    TypedLiteral literal = parseListOrMapLiteral(null, '[1]');
-    expect(literal, isNotNull);
-    assertNoErrors();
-    var listLiteral = literal as ListLiteral;
-    expect(listLiteral.constKeyword, isNull);
-    expect(listLiteral.typeArguments, isNull);
-    expect(listLiteral.leftBracket, isNotNull);
-    expect(listLiteral.elements, hasLength(1));
-    expect(listLiteral.rightBracket, isNotNull);
-  }
-
-  void test_parseListOrMapLiteral_list_type() {
-    TypedLiteral literal = parseListOrMapLiteral(null, '<int> [1]');
-    expect(literal, isNotNull);
-    assertNoErrors();
-    var listLiteral = literal as ListLiteral;
-    expect(listLiteral.constKeyword, isNull);
-    expect(listLiteral.typeArguments, isNotNull);
-    expect(listLiteral.leftBracket, isNotNull);
-    expect(listLiteral.elements, hasLength(1));
-    expect(listLiteral.rightBracket, isNotNull);
-  }
-
-  void test_parseListOrMapLiteral_map_noType() {
-    TypedLiteral literal = parseListOrMapLiteral(null, "{'1' : 1}");
-    expect(literal, isNotNull);
-    assertNoErrors();
-    var mapLiteral = literal as SetOrMapLiteral;
-    expect(mapLiteral.constKeyword, isNull);
-    expect(mapLiteral.typeArguments, isNull);
-    expect(mapLiteral.leftBracket, isNotNull);
-    expect(mapLiteral.elements, hasLength(1));
-    expect(mapLiteral.rightBracket, isNotNull);
-  }
-
-  void test_parseListOrMapLiteral_map_type() {
-    TypedLiteral literal =
-        parseListOrMapLiteral(null, "<String, int> {'1' : 1}");
-    expect(literal, isNotNull);
-    assertNoErrors();
-    var mapLiteral = literal as SetOrMapLiteral;
-    expect(mapLiteral.constKeyword, isNull);
-    expect(mapLiteral.typeArguments, isNotNull);
-    expect(mapLiteral.leftBracket, isNotNull);
-    expect(mapLiteral.elements, hasLength(1));
-    expect(mapLiteral.rightBracket, isNotNull);
-  }
-
-  void test_parseLogicalAndExpression() {
-    Expression expression = parseLogicalAndExpression('x && y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, isNotNull);
-    expect(binaryExpression.operator, isNotNull);
-    expect(binaryExpression.operator.type, TokenType.AMPERSAND_AMPERSAND);
-    expect(binaryExpression.rightOperand, isNotNull);
-  }
-
-  void test_parseLogicalOrExpression() {
-    Expression expression = parseLogicalOrExpression('x || y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, isNotNull);
-    expect(binaryExpression.operator, isNotNull);
-    expect(binaryExpression.operator.type, TokenType.BAR_BAR);
-    expect(binaryExpression.rightOperand, isNotNull);
-  }
-
-  void test_parseMapLiteral_empty() {
-    Token token = TokenFactory.tokenFromKeyword(Keyword.CONST);
-    SetOrMapLiteral literal = parseMapLiteral(token, '<String, int>', '{}');
-    expect(literal, isNotNull);
-    assertNoErrors();
-    expect(literal.constKeyword.keyword, Keyword.CONST);
-    expect(literal.typeArguments, isNotNull);
-    expect(literal.leftBracket, isNotNull);
-    expect(literal.elements, hasLength(0));
-    expect(literal.rightBracket, isNotNull);
-  }
-
-  void test_parseMapLiteral_multiple() {
-    SetOrMapLiteral literal = parseMapLiteral(null, null, "{'a' : b, 'x' : y}");
-    expect(literal, isNotNull);
-    assertNoErrors();
-    expect(literal.leftBracket, isNotNull);
-    expect(literal.elements, hasLength(2));
-    expect(literal.rightBracket, isNotNull);
-  }
-
-  void test_parseMapLiteral_multiple_trailing_comma() {
-    SetOrMapLiteral literal =
-        parseMapLiteral(null, null, "{'a' : b, 'x' : y,}");
-    expect(literal, isNotNull);
-    assertNoErrors();
-    expect(literal.leftBracket, isNotNull);
-    expect(literal.elements, hasLength(2));
-    expect(literal.rightBracket, isNotNull);
-  }
-
-  void test_parseMapLiteral_single() {
-    SetOrMapLiteral literal = parseMapLiteral(null, null, "{'x' : y}");
-    expect(literal, isNotNull);
-    assertNoErrors();
-    expect(literal.leftBracket, isNotNull);
-    expect(literal.elements, hasLength(1));
-    expect(literal.rightBracket, isNotNull);
-  }
-
-  void test_parseMapLiteralEntry_complex() {
-    MapLiteralEntry entry = parseMapLiteralEntry('2 + 2 : y');
-    expect(entry, isNotNull);
-    assertNoErrors();
-    expect(entry.key, isNotNull);
-    expect(entry.separator, isNotNull);
-    expect(entry.value, isNotNull);
-  }
-
-  void test_parseMapLiteralEntry_int() {
-    MapLiteralEntry entry = parseMapLiteralEntry('0 : y');
-    expect(entry, isNotNull);
-    assertNoErrors();
-    expect(entry.key, isNotNull);
-    expect(entry.separator, isNotNull);
-    expect(entry.value, isNotNull);
-  }
-
-  void test_parseMapLiteralEntry_string() {
-    MapLiteralEntry entry = parseMapLiteralEntry("'x' : y");
-    expect(entry, isNotNull);
-    assertNoErrors();
-    expect(entry.key, isNotNull);
-    expect(entry.separator, isNotNull);
-    expect(entry.value, isNotNull);
-  }
-
-  void test_parseMultiplicativeExpression_normal() {
-    Expression expression = parseMultiplicativeExpression('x * y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, isNotNull);
-    expect(binaryExpression.operator, isNotNull);
-    expect(binaryExpression.operator.type, TokenType.STAR);
-    expect(binaryExpression.rightOperand, isNotNull);
-  }
-
-  void test_parseMultiplicativeExpression_super() {
-    Expression expression = parseMultiplicativeExpression('super * y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, isSuperExpression);
-    expect(binaryExpression.operator, isNotNull);
-    expect(binaryExpression.operator.type, TokenType.STAR);
-    expect(binaryExpression.rightOperand, isNotNull);
-  }
-
-  void test_parseNewExpression() {
-    InstanceCreationExpression expression = parseNewExpression('new A()');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.keyword, isNotNull);
-    ConstructorName name = expression.constructorName;
-    expect(name, isNotNull);
-    expect(name.type, isNotNull);
-    expect(name.period, isNull);
-    expect(name.name, isNull);
-    expect(expression.argumentList, isNotNull);
-  }
-
-  void test_parsePostfixExpression_decrement() {
-    Expression expression = parsePostfixExpression('i--');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var postfixExpression = expression as PostfixExpression;
-    expect(postfixExpression.operand, isNotNull);
-    expect(postfixExpression.operator, isNotNull);
-    expect(postfixExpression.operator.type, TokenType.MINUS_MINUS);
-  }
-
-  void test_parsePostfixExpression_increment() {
-    Expression expression = parsePostfixExpression('i++');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var postfixExpression = expression as PostfixExpression;
-    expect(postfixExpression.operand, isNotNull);
-    expect(postfixExpression.operator, isNotNull);
-    expect(postfixExpression.operator.type, TokenType.PLUS_PLUS);
-  }
-
-  void test_parsePostfixExpression_none_indexExpression() {
-    Expression expression = parsePostfixExpression('a[0]');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var indexExpression = expression as IndexExpression;
-    expect(indexExpression.target, isNotNull);
-    expect(indexExpression.index, isNotNull);
-  }
-
-  void test_parsePostfixExpression_none_methodInvocation() {
-    Expression expression = parsePostfixExpression('a.m()');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var methodInvocation = expression as MethodInvocation;
-    expect(methodInvocation.target, isNotNull);
-    expect(methodInvocation.operator.type, TokenType.PERIOD);
-    expect(methodInvocation.methodName, isNotNull);
-    expect(methodInvocation.typeArguments, isNull);
-    expect(methodInvocation.argumentList, isNotNull);
-  }
-
-  void test_parsePostfixExpression_none_methodInvocation_question_dot() {
-    Expression expression = parsePostfixExpression('a?.m()');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var methodInvocation = expression as MethodInvocation;
-    expect(methodInvocation.target, isNotNull);
-    expect(methodInvocation.operator.type, TokenType.QUESTION_PERIOD);
-    expect(methodInvocation.methodName, isNotNull);
-    expect(methodInvocation.typeArguments, isNull);
-    expect(methodInvocation.argumentList, isNotNull);
-  }
-
-  void
-      test_parsePostfixExpression_none_methodInvocation_question_dot_typeArguments() {
-    Expression expression = parsePostfixExpression('a?.m<E>()');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var methodInvocation = expression as MethodInvocation;
-    expect(methodInvocation.target, isNotNull);
-    expect(methodInvocation.operator.type, TokenType.QUESTION_PERIOD);
-    expect(methodInvocation.methodName, isNotNull);
-    expect(methodInvocation.typeArguments, isNotNull);
-    expect(methodInvocation.argumentList, isNotNull);
-  }
-
-  void test_parsePostfixExpression_none_methodInvocation_typeArguments() {
-    Expression expression = parsePostfixExpression('a.m<E>()');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var methodInvocation = expression as MethodInvocation;
-    expect(methodInvocation.target, isNotNull);
-    expect(methodInvocation.operator.type, TokenType.PERIOD);
-    expect(methodInvocation.methodName, isNotNull);
-    expect(methodInvocation.typeArguments, isNotNull);
-    expect(methodInvocation.argumentList, isNotNull);
-  }
-
-  void test_parsePostfixExpression_none_propertyAccess() {
-    Expression expression = parsePostfixExpression('a.b');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var identifier = expression as PrefixedIdentifier;
-    expect(identifier.prefix, isNotNull);
-    expect(identifier.identifier, isNotNull);
-  }
-
-  void test_parsePrefixedIdentifier_noPrefix() {
-    String lexeme = "bar";
-    Identifier identifier = parsePrefixedIdentifier(lexeme);
-    expect(identifier, isNotNull);
-    assertNoErrors();
-    var simpleIdentifier = identifier as SimpleIdentifier;
-    expect(simpleIdentifier.token, isNotNull);
-    expect(simpleIdentifier.name, lexeme);
-  }
-
-  void test_parsePrefixedIdentifier_prefix() {
-    String lexeme = "foo.bar";
-    Identifier identifier = parsePrefixedIdentifier(lexeme);
-    expect(identifier, isNotNull);
-    assertNoErrors();
-    var prefixedIdentifier = identifier as PrefixedIdentifier;
-    expect(prefixedIdentifier.prefix.name, "foo");
-    expect(prefixedIdentifier.period, isNotNull);
-    expect(prefixedIdentifier.identifier.name, "bar");
-  }
-
-  void test_parsePrimaryExpression_const() {
-    Expression expression = parsePrimaryExpression('const A()');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression, isNotNull);
-  }
-
-  void test_parsePrimaryExpression_double() {
-    String doubleLiteral = "3.2e4";
-    Expression expression = parsePrimaryExpression(doubleLiteral);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as DoubleLiteral;
-    expect(literal.literal, isNotNull);
-    expect(literal.value, double.parse(doubleLiteral));
-  }
-
-  void test_parsePrimaryExpression_false() {
-    Expression expression = parsePrimaryExpression('false');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as BooleanLiteral;
-    expect(literal.literal, isNotNull);
-    expect(literal.value, isFalse);
-  }
-
-  void test_parsePrimaryExpression_function_arguments() {
-    Expression expression = parsePrimaryExpression('(int i) => i + 1');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var functionExpression = expression as FunctionExpression;
-    expect(functionExpression.parameters, isNotNull);
-    expect(functionExpression.body, isNotNull);
-  }
-
-  void test_parsePrimaryExpression_function_noArguments() {
-    Expression expression = parsePrimaryExpression('() => 42');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var functionExpression = expression as FunctionExpression;
-    expect(functionExpression.parameters, isNotNull);
-    expect(functionExpression.body, isNotNull);
-  }
-
-  void test_parsePrimaryExpression_genericFunctionExpression() {
-    Expression expression =
-        parsePrimaryExpression('<X, Y>(Map<X, Y> m, X x) => m[x]');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var functionExpression = expression as FunctionExpression;
-    expect(functionExpression.typeParameters, isNotNull);
-  }
-
-  void test_parsePrimaryExpression_hex() {
-    String hexLiteral = "3F";
-    Expression expression = parsePrimaryExpression('0x$hexLiteral');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as IntegerLiteral;
-    expect(literal.literal, isNotNull);
-    expect(literal.value, int.parse(hexLiteral, radix: 16));
-  }
-
-  void test_parsePrimaryExpression_identifier() {
-    Expression expression = parsePrimaryExpression('a');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var identifier = expression as SimpleIdentifier;
-    expect(identifier, isNotNull);
-  }
-
-  void test_parsePrimaryExpression_int() {
-    String intLiteral = "472";
-    Expression expression = parsePrimaryExpression(intLiteral);
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as IntegerLiteral;
-    expect(literal.literal, isNotNull);
-    expect(literal.value, int.parse(intLiteral));
-  }
-
-  void test_parsePrimaryExpression_listLiteral() {
-    Expression expression = parsePrimaryExpression('[ ]');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as ListLiteral;
-    expect(literal, isNotNull);
-  }
-
-  void test_parsePrimaryExpression_listLiteral_index() {
-    Expression expression = parsePrimaryExpression('[]');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as ListLiteral;
-    expect(literal, isNotNull);
-  }
-
-  void test_parsePrimaryExpression_listLiteral_typed() {
-    Expression expression = parsePrimaryExpression('<A>[ ]');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as ListLiteral;
-    expect(literal.typeArguments, isNotNull);
-    expect(literal.typeArguments.arguments, hasLength(1));
-  }
-
-  void test_parsePrimaryExpression_mapLiteral() {
-    Expression expression = parsePrimaryExpression('{}');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as SetOrMapLiteral;
-    expect(literal.typeArguments, isNull);
-    expect(literal, isNotNull);
-  }
-
-  void test_parsePrimaryExpression_mapLiteral_typed() {
-    Expression expression = parsePrimaryExpression('<A, B>{}');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as SetOrMapLiteral;
-    expect(literal.typeArguments, isNotNull);
-    expect(literal.typeArguments.arguments, hasLength(2));
-  }
-
-  void test_parsePrimaryExpression_new() {
-    Expression expression = parsePrimaryExpression('new A()');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var creation = expression as InstanceCreationExpression;
-    expect(creation, isNotNull);
-  }
-
-  void test_parsePrimaryExpression_null() {
-    Expression expression = parsePrimaryExpression('null');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression, isNullLiteral);
-    NullLiteral literal = expression;
-    expect(literal.literal, isNotNull);
-  }
-
-  void test_parsePrimaryExpression_parenthesized() {
-    Expression expression = parsePrimaryExpression('(x)');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var parens = expression as ParenthesizedExpression;
-    expect(parens, isNotNull);
-  }
-
-  void test_parsePrimaryExpression_string() {
-    Expression expression = parsePrimaryExpression('"string"');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as SimpleStringLiteral;
-    expect(literal.isMultiline, isFalse);
-    expect(literal.isRaw, isFalse);
-    expect(literal.value, "string");
-  }
-
-  void test_parsePrimaryExpression_string_multiline() {
-    Expression expression = parsePrimaryExpression("'''string'''");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as SimpleStringLiteral;
-    expect(literal.isMultiline, isTrue);
-    expect(literal.isRaw, isFalse);
-    expect(literal.value, "string");
-  }
-
-  void test_parsePrimaryExpression_string_raw() {
-    Expression expression = parsePrimaryExpression("r'string'");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as SimpleStringLiteral;
-    expect(literal.isMultiline, isFalse);
-    expect(literal.isRaw, isTrue);
-    expect(literal.value, "string");
-  }
-
-  void test_parsePrimaryExpression_super() {
-    Expression expression = parseExpression('super.x');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var propertyAccess = expression as PropertyAccess;
-    expect(propertyAccess.target is SuperExpression, isTrue);
-    expect(propertyAccess.operator, isNotNull);
-    expect(propertyAccess.operator.type, TokenType.PERIOD);
-    expect(propertyAccess.propertyName, isNotNull);
-  }
-
-  void test_parsePrimaryExpression_this() {
-    Expression expression = parsePrimaryExpression('this');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var thisExpression = expression as ThisExpression;
-    expect(thisExpression.thisKeyword, isNotNull);
-  }
-
-  void test_parsePrimaryExpression_true() {
-    Expression expression = parsePrimaryExpression('true');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as BooleanLiteral;
-    expect(literal.literal, isNotNull);
-    expect(literal.value, isTrue);
-  }
-
-  void test_parseRedirectingConstructorInvocation_named() {
-    var invocation = parseConstructorInitializer('this.a()')
-        as RedirectingConstructorInvocation;
-    assertNoErrors();
-    expect(invocation.argumentList, isNotNull);
-    expect(invocation.constructorName, isNotNull);
-    expect(invocation.thisKeyword, isNotNull);
-    expect(invocation.period, isNotNull);
-  }
-
-  void test_parseRedirectingConstructorInvocation_unnamed() {
-    var invocation = parseConstructorInitializer('this()')
-        as RedirectingConstructorInvocation;
-    assertNoErrors();
-    expect(invocation.argumentList, isNotNull);
-    expect(invocation.constructorName, isNull);
-    expect(invocation.thisKeyword, isNotNull);
-    expect(invocation.period, isNull);
-  }
-
-  void test_parseRelationalExpression_as_chained() {
-    AsExpression asExpression = parseExpression('x as Y as Z',
-        errors: [expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 7, 2)]);
-    expect(asExpression, isNotNull);
-    SimpleIdentifier identifier = asExpression.expression;
-    expect(identifier.name, 'x');
-    expect(asExpression.asOperator, isNotNull);
-    TypeName typeName = asExpression.type;
-    expect(typeName.name.name, 'Y');
-  }
-
-  void test_parseRelationalExpression_as_functionType_noReturnType() {
-    Expression expression = parseRelationalExpression('x as Function(int)');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var asExpression = expression as AsExpression;
-    expect(asExpression.expression, isNotNull);
-    expect(asExpression.asOperator, isNotNull);
-    expect(asExpression.type, isGenericFunctionType);
-  }
-
-  void test_parseRelationalExpression_as_functionType_returnType() {
-    Expression expression =
-        parseRelationalExpression('x as String Function(int)');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var asExpression = expression as AsExpression;
-    expect(asExpression.expression, isNotNull);
-    expect(asExpression.asOperator, isNotNull);
-    expect(asExpression.type, isGenericFunctionType);
-  }
-
-  void test_parseRelationalExpression_as_generic() {
-    Expression expression = parseRelationalExpression('x as C<D>');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var asExpression = expression as AsExpression;
-    expect(asExpression.expression, isNotNull);
-    expect(asExpression.asOperator, isNotNull);
-    expect(asExpression.type, isTypeName);
-  }
-
-  void test_parseRelationalExpression_as_simple() {
-    Expression expression = parseRelationalExpression('x as Y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var asExpression = expression as AsExpression;
-    expect(asExpression.expression, isNotNull);
-    expect(asExpression.asOperator, isNotNull);
-    expect(asExpression.type, isTypeName);
-  }
-
-  void test_parseRelationalExpression_as_simple_function() {
-    Expression expression = parseRelationalExpression('x as Function');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var asExpression = expression as AsExpression;
-    expect(asExpression.expression, isNotNull);
-    expect(asExpression.asOperator, isNotNull);
-    expect(asExpression.type, isTypeName);
-  }
-
-  void test_parseRelationalExpression_is() {
-    Expression expression = parseRelationalExpression('x is y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var isExpression = expression as IsExpression;
-    expect(isExpression.expression, isNotNull);
-    expect(isExpression.isOperator, isNotNull);
-    expect(isExpression.notOperator, isNull);
-    expect(isExpression.type, isNotNull);
-  }
-
-  void test_parseRelationalExpression_is_chained() {
-    IsExpression isExpression = parseExpression('x is Y is! Z',
-        errors: [expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 7, 2)]);
-    expect(isExpression, isNotNull);
-    SimpleIdentifier identifier = isExpression.expression;
-    expect(identifier.name, 'x');
-    expect(isExpression.isOperator, isNotNull);
-    TypeName typeName = isExpression.type;
-    expect(typeName.name.name, 'Y');
-  }
-
-  void test_parseRelationalExpression_isNot() {
-    Expression expression = parseRelationalExpression('x is! y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var isExpression = expression as IsExpression;
-    expect(isExpression.expression, isNotNull);
-    expect(isExpression.isOperator, isNotNull);
-    expect(isExpression.notOperator, isNotNull);
-    expect(isExpression.type, isNotNull);
-  }
-
-  void test_parseRelationalExpression_normal() {
-    Expression expression = parseRelationalExpression('x < y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, isNotNull);
-    expect(binaryExpression.operator, isNotNull);
-    expect(binaryExpression.operator.type, TokenType.LT);
-    expect(binaryExpression.rightOperand, isNotNull);
-  }
-
-  void test_parseRelationalExpression_super() {
-    Expression expression = parseRelationalExpression('super < y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var binaryExpression = expression as BinaryExpression;
-    expect(binaryExpression.leftOperand, isNotNull);
-    expect(binaryExpression.operator, isNotNull);
-    expect(binaryExpression.operator.type, TokenType.LT);
-    expect(binaryExpression.rightOperand, isNotNull);
-  }
-
-  void test_parseRethrowExpression() {
-    RethrowExpression expression = parseRethrowExpression('rethrow');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.rethrowKeyword, isNotNull);
-  }
-
-  void test_parseShiftExpression_normal() {
-    BinaryExpression expression = parseShiftExpression('x << y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.leftOperand, isNotNull);
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.LT_LT);
-    expect(expression.rightOperand, isNotNull);
-  }
-
-  void test_parseShiftExpression_super() {
-    BinaryExpression expression = parseShiftExpression('super << y');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.leftOperand, isNotNull);
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.LT_LT);
-    expect(expression.rightOperand, isNotNull);
-  }
-
-  void test_parseSimpleIdentifier1_normalIdentifier() {
-    // TODO(brianwilkerson) Implement tests for this method.
-  }
-
-  void test_parseSimpleIdentifier_builtInIdentifier() {
-    String lexeme = "as";
-    SimpleIdentifier identifier = parseSimpleIdentifier(lexeme);
-    expect(identifier, isNotNull);
-    assertNoErrors();
-    expect(identifier.token, isNotNull);
-    expect(identifier.name, lexeme);
-  }
-
-  void test_parseSimpleIdentifier_normalIdentifier() {
-    String lexeme = "foo";
-    SimpleIdentifier identifier = parseSimpleIdentifier(lexeme);
-    expect(identifier, isNotNull);
-    assertNoErrors();
-    expect(identifier.token, isNotNull);
-    expect(identifier.name, lexeme);
-  }
-
-  void test_parseStringLiteral_adjacent() {
-    Expression expression = parseStringLiteral("'a' 'b'");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as AdjacentStrings;
-    NodeList<StringLiteral> strings = literal.strings;
-    expect(strings, hasLength(2));
-    StringLiteral firstString = strings[0];
-    StringLiteral secondString = strings[1];
-    expect((firstString as SimpleStringLiteral).value, "a");
-    expect((secondString as SimpleStringLiteral).value, "b");
-  }
-
-  void test_parseStringLiteral_endsWithInterpolation() {
-    Expression expression = parseStringLiteral(r"'x$y'");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var interpolation = expression as StringInterpolation;
-    expect(interpolation.elements, hasLength(3));
-    expect(interpolation.elements[0], isInterpolationString);
-    InterpolationString element0 = interpolation.elements[0];
-    expect(element0.value, 'x');
-    expect(interpolation.elements[1], isInterpolationExpression);
-    InterpolationExpression element1 = interpolation.elements[1];
-    expect(element1.leftBracket.lexeme, '\$');
-    expect(element1.expression, isSimpleIdentifier);
-    expect(element1.rightBracket, isNull);
-    expect(interpolation.elements[2], isInterpolationString);
-    InterpolationString element2 = interpolation.elements[2];
-    expect(element2.value, '');
-  }
-
-  void test_parseStringLiteral_interpolated() {
-    Expression expression = parseStringLiteral("'a \${b} c \$this d'");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression, isStringInterpolation);
-    StringInterpolation literal = expression;
-    NodeList<InterpolationElement> elements = literal.elements;
-    expect(elements, hasLength(5));
-    expect(elements[0] is InterpolationString, isTrue);
-    expect(elements[1] is InterpolationExpression, isTrue);
-    expect(elements[2] is InterpolationString, isTrue);
-    expect(elements[3] is InterpolationExpression, isTrue);
-    expect(elements[4] is InterpolationString, isTrue);
-    expect((elements[1] as InterpolationExpression).leftBracket.lexeme, '\${');
-    expect((elements[1] as InterpolationExpression).rightBracket.lexeme, '}');
-    expect((elements[3] as InterpolationExpression).leftBracket.lexeme, '\$');
-    expect((elements[3] as InterpolationExpression).rightBracket, isNull);
-  }
-
-  void test_parseStringLiteral_multiline_encodedSpace() {
-    Expression expression = parseStringLiteral("'''\\x20\na'''");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as SimpleStringLiteral;
-    expect(literal.literal, isNotNull);
-    expect(literal.value, " \na");
-  }
-
-  void test_parseStringLiteral_multiline_endsWithInterpolation() {
-    Expression expression = parseStringLiteral(r"'''x$y'''");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var interpolation = expression as StringInterpolation;
-    expect(interpolation.elements, hasLength(3));
-    expect(interpolation.elements[0], isInterpolationString);
-    InterpolationString element0 = interpolation.elements[0];
-    expect(element0.value, 'x');
-    expect(interpolation.elements[1], isInterpolationExpression);
-    InterpolationExpression element1 = interpolation.elements[1];
-    expect(element1.expression, isSimpleIdentifier);
-    expect(interpolation.elements[2], isInterpolationString);
-    InterpolationString element2 = interpolation.elements[2];
-    expect(element2.value, '');
-  }
-
-  void test_parseStringLiteral_multiline_escapedBackslash() {
-    Expression expression = parseStringLiteral("'''\\\\\na'''");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as SimpleStringLiteral;
-    expect(literal.literal, isNotNull);
-    expect(literal.value, "\\\na");
-  }
-
-  void test_parseStringLiteral_multiline_escapedBackslash_raw() {
-    Expression expression = parseStringLiteral("r'''\\\\\na'''");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as SimpleStringLiteral;
-    expect(literal.literal, isNotNull);
-    expect(literal.value, "\\\\\na");
-  }
-
-  void test_parseStringLiteral_multiline_escapedEolMarker() {
-    Expression expression = parseStringLiteral("'''\\\na'''");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as SimpleStringLiteral;
-    expect(literal.literal, isNotNull);
-    expect(literal.value, "a");
-  }
-
-  void test_parseStringLiteral_multiline_escapedEolMarker_raw() {
-    Expression expression = parseStringLiteral("r'''\\\na'''");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as SimpleStringLiteral;
-    expect(literal.literal, isNotNull);
-    expect(literal.value, "a");
-  }
-
-  void test_parseStringLiteral_multiline_escapedSpaceAndEolMarker() {
-    Expression expression = parseStringLiteral("'''\\ \\\na'''");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as SimpleStringLiteral;
-    expect(literal.literal, isNotNull);
-    expect(literal.value, "a");
-  }
-
-  void test_parseStringLiteral_multiline_escapedSpaceAndEolMarker_raw() {
-    Expression expression = parseStringLiteral("r'''\\ \\\na'''");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as SimpleStringLiteral;
-    expect(literal.literal, isNotNull);
-    expect(literal.value, "a");
-  }
-
-  void test_parseStringLiteral_multiline_escapedTab() {
-    Expression expression = parseStringLiteral("'''\\t\na'''");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as SimpleStringLiteral;
-    expect(literal.literal, isNotNull);
-    expect(literal.value, "\t\na");
-  }
-
-  void test_parseStringLiteral_multiline_escapedTab_raw() {
-    Expression expression = parseStringLiteral("r'''\\t\na'''");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as SimpleStringLiteral;
-    expect(literal.literal, isNotNull);
-    expect(literal.value, "\\t\na");
-  }
-
-  void test_parseStringLiteral_multiline_quoteAfterInterpolation() {
-    Expression expression = parseStringLiteral(r"""'''$x'y'''""");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var interpolation = expression as StringInterpolation;
-    expect(interpolation.elements, hasLength(3));
-    expect(interpolation.elements[0], isInterpolationString);
-    InterpolationString element0 = interpolation.elements[0];
-    expect(element0.value, '');
-    expect(interpolation.elements[1], isInterpolationExpression);
-    InterpolationExpression element1 = interpolation.elements[1];
-    expect(element1.expression, isSimpleIdentifier);
-    expect(interpolation.elements[2], isInterpolationString);
-    InterpolationString element2 = interpolation.elements[2];
-    expect(element2.value, "'y");
-  }
-
-  void test_parseStringLiteral_multiline_startsWithInterpolation() {
-    Expression expression = parseStringLiteral(r"'''${x}y'''");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var interpolation = expression as StringInterpolation;
-    expect(interpolation.elements, hasLength(3));
-    expect(interpolation.elements[0], isInterpolationString);
-    InterpolationString element0 = interpolation.elements[0];
-    expect(element0.value, '');
-    expect(interpolation.elements[1], isInterpolationExpression);
-    InterpolationExpression element1 = interpolation.elements[1];
-    expect(element1.expression, isSimpleIdentifier);
-    expect(interpolation.elements[2], isInterpolationString);
-    InterpolationString element2 = interpolation.elements[2];
-    expect(element2.value, 'y');
-  }
-
-  void test_parseStringLiteral_multiline_twoSpaces() {
-    Expression expression = parseStringLiteral("'''  \na'''");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as SimpleStringLiteral;
-    expect(literal.literal, isNotNull);
-    expect(literal.value, "a");
-  }
-
-  void test_parseStringLiteral_multiline_twoSpaces_raw() {
-    Expression expression = parseStringLiteral("r'''  \na'''");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as SimpleStringLiteral;
-    expect(literal.literal, isNotNull);
-    expect(literal.value, "a");
-  }
-
-  void test_parseStringLiteral_multiline_untrimmed() {
-    Expression expression = parseStringLiteral("''' a\nb'''");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as SimpleStringLiteral;
-    expect(literal.literal, isNotNull);
-    expect(literal.value, " a\nb");
-  }
-
-  void test_parseStringLiteral_quoteAfterInterpolation() {
-    Expression expression = parseStringLiteral(r"""'$x"'""");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var interpolation = expression as StringInterpolation;
-    expect(interpolation.elements, hasLength(3));
-    expect(interpolation.elements[0], isInterpolationString);
-    InterpolationString element0 = interpolation.elements[0];
-    expect(element0.value, '');
-    expect(interpolation.elements[1], isInterpolationExpression);
-    InterpolationExpression element1 = interpolation.elements[1];
-    expect(element1.expression, isSimpleIdentifier);
-    expect(interpolation.elements[2], isInterpolationString);
-    InterpolationString element2 = interpolation.elements[2];
-    expect(element2.value, '"');
-  }
-
-  void test_parseStringLiteral_single() {
-    Expression expression = parseStringLiteral("'a'");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var literal = expression as SimpleStringLiteral;
-    expect(literal.literal, isNotNull);
-    expect(literal.value, "a");
-  }
-
-  void test_parseStringLiteral_startsWithInterpolation() {
-    Expression expression = parseStringLiteral(r"'${x}y'");
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var interpolation = expression as StringInterpolation;
-    expect(interpolation.elements, hasLength(3));
-    expect(interpolation.elements[0], isInterpolationString);
-    InterpolationString element0 = interpolation.elements[0];
-    expect(element0.value, '');
-    expect(interpolation.elements[1], isInterpolationExpression);
-    InterpolationExpression element1 = interpolation.elements[1];
-    expect(element1.expression, isSimpleIdentifier);
-    expect(interpolation.elements[2], isInterpolationString);
-    InterpolationString element2 = interpolation.elements[2];
-    expect(element2.value, 'y');
-  }
-
-  void test_parseSuperConstructorInvocation_named() {
-    var invocation =
-        parseConstructorInitializer('super.a()') as SuperConstructorInvocation;
-    expect(invocation, isNotNull);
-    assertNoErrors();
-    expect(invocation.argumentList, isNotNull);
-    expect(invocation.constructorName, isNotNull);
-    expect(invocation.superKeyword, isNotNull);
-    expect(invocation.period, isNotNull);
-  }
-
-  void test_parseSuperConstructorInvocation_unnamed() {
-    var invocation =
-        parseConstructorInitializer('super()') as SuperConstructorInvocation;
-    assertNoErrors();
-    expect(invocation.argumentList, isNotNull);
-    expect(invocation.constructorName, isNull);
-    expect(invocation.superKeyword, isNotNull);
-    expect(invocation.period, isNull);
-  }
-
-  void test_parseSymbolLiteral_builtInIdentifier() {
-    SymbolLiteral literal = parseSymbolLiteral('#dynamic.static.abstract');
-    expect(literal, isNotNull);
-    assertNoErrors();
-    expect(literal.poundSign, isNotNull);
-    List<Token> components = literal.components;
-    expect(components, hasLength(3));
-    expect(components[0].lexeme, "dynamic");
-    expect(components[1].lexeme, "static");
-    expect(components[2].lexeme, "abstract");
-  }
-
-  void test_parseSymbolLiteral_multiple() {
-    SymbolLiteral literal = parseSymbolLiteral('#a.b.c');
-    expect(literal, isNotNull);
-    assertNoErrors();
-    expect(literal.poundSign, isNotNull);
-    List<Token> components = literal.components;
-    expect(components, hasLength(3));
-    expect(components[0].lexeme, "a");
-    expect(components[1].lexeme, "b");
-    expect(components[2].lexeme, "c");
-  }
-
-  void test_parseSymbolLiteral_operator() {
-    SymbolLiteral literal = parseSymbolLiteral('#==');
-    expect(literal, isNotNull);
-    assertNoErrors();
-    expect(literal.poundSign, isNotNull);
-    List<Token> components = literal.components;
-    expect(components, hasLength(1));
-    expect(components[0].lexeme, "==");
-  }
-
-  void test_parseSymbolLiteral_single() {
-    SymbolLiteral literal = parseSymbolLiteral('#a');
-    expect(literal, isNotNull);
-    assertNoErrors();
-    expect(literal.poundSign, isNotNull);
-    List<Token> components = literal.components;
-    expect(components, hasLength(1));
-    expect(components[0].lexeme, "a");
-  }
-
-  void test_parseSymbolLiteral_void() {
-    SymbolLiteral literal = parseSymbolLiteral('#void');
-    expect(literal, isNotNull);
-    assertNoErrors();
-    expect(literal.poundSign, isNotNull);
-    List<Token> components = literal.components;
-    expect(components, hasLength(1));
-    expect(components[0].lexeme, "void");
-  }
-
-  void test_parseThrowExpression() {
-    Expression expression = parseThrowExpression('throw x');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var throwExpression = expression as ThrowExpression;
-    expect(throwExpression.throwKeyword, isNotNull);
-    expect(throwExpression.expression, isNotNull);
-  }
-
-  void test_parseThrowExpressionWithoutCascade() {
-    Expression expression = parseThrowExpressionWithoutCascade('throw x');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    var throwExpression = expression as ThrowExpression;
-    expect(throwExpression.throwKeyword, isNotNull);
-    expect(throwExpression.expression, isNotNull);
-  }
-
-  void test_parseUnaryExpression_decrement_identifier_index() {
-    PrefixExpression expression = parseExpression('--a[0]');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.MINUS_MINUS);
-    expect(expression.operand, isNotNull);
-    IndexExpression operand = expression.operand as IndexExpression;
-    expect(operand.realTarget, const TypeMatcher<SimpleIdentifier>());
-    expect(operand.index is IntegerLiteral, isTrue);
-  }
-
-  void test_parseUnaryExpression_decrement_normal() {
-    PrefixExpression expression = parseUnaryExpression('--x');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.MINUS_MINUS);
-    expect(expression.operand, isNotNull);
-  }
-
-  void test_parseUnaryExpression_decrement_super() {
-    PrefixExpression expression = parseUnaryExpression('--super');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.MINUS);
-    Expression innerExpression = expression.operand;
-    expect(innerExpression, isNotNull);
-    expect(innerExpression is PrefixExpression, isTrue);
-    PrefixExpression operand = innerExpression as PrefixExpression;
-    expect(operand.operator, isNotNull);
-    expect(operand.operator.type, TokenType.MINUS);
-    expect(operand.operand, isNotNull);
-  }
-
-  void test_parseUnaryExpression_decrement_super_propertyAccess() {
-    PrefixExpression expression = parseUnaryExpression('--super.x');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.MINUS_MINUS);
-    expect(expression.operand, isNotNull);
-    PropertyAccess operand = expression.operand as PropertyAccess;
-    expect(operand.target is SuperExpression, isTrue);
-    expect(operand.propertyName.name, "x");
-  }
-
-  void test_parseUnaryExpression_decrement_super_withComment() {}
-
-  void test_parseUnaryExpression_increment_identifier_index() {
-    PrefixExpression expression = parseExpression('++a[0]');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.PLUS_PLUS);
-    expect(expression.operand, isNotNull);
-    IndexExpression operand = expression.operand as IndexExpression;
-    expect(operand.realTarget, const TypeMatcher<SimpleIdentifier>());
-    expect(operand.index is IntegerLiteral, isTrue);
-  }
-
-  void test_parseUnaryExpression_increment_normal() {
-    PrefixExpression expression = parseUnaryExpression('++x');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.PLUS_PLUS);
-    expect(expression.operand, isNotNull);
-  }
-
-  void test_parseUnaryExpression_increment_super_index() {
-    PrefixExpression expression = parseUnaryExpression('++super[0]');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.PLUS_PLUS);
-    expect(expression.operand, isNotNull);
-    IndexExpression operand = expression.operand as IndexExpression;
-    expect(operand.realTarget is SuperExpression, isTrue);
-    expect(operand.index is IntegerLiteral, isTrue);
-  }
-
-  void test_parseUnaryExpression_increment_super_propertyAccess() {
-    PrefixExpression expression = parseUnaryExpression('++super.x');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.PLUS_PLUS);
-    expect(expression.operand, isNotNull);
-    PropertyAccess operand = expression.operand as PropertyAccess;
-    expect(operand.target is SuperExpression, isTrue);
-    expect(operand.propertyName.name, "x");
-  }
-
-  void test_parseUnaryExpression_minus_identifier_index() {
-    PrefixExpression expression = parseExpression('-a[0]');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.MINUS);
-    expect(expression.operand, isNotNull);
-    IndexExpression operand = expression.operand as IndexExpression;
-    expect(operand.realTarget, const TypeMatcher<SimpleIdentifier>());
-    expect(operand.index is IntegerLiteral, isTrue);
-  }
-
-  void test_parseUnaryExpression_minus_normal() {
-    PrefixExpression expression = parseUnaryExpression('-x');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.MINUS);
-    expect(expression.operand, isNotNull);
-  }
-
-  void test_parseUnaryExpression_minus_super() {
-    PrefixExpression expression = parseUnaryExpression('-super');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.MINUS);
-    expect(expression.operand, isNotNull);
-  }
-
-  void test_parseUnaryExpression_not_normal() {
-    PrefixExpression expression = parseUnaryExpression('!x');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.BANG);
-    expect(expression.operand, isNotNull);
-  }
-
-  void test_parseUnaryExpression_not_super() {
-    PrefixExpression expression = parseUnaryExpression('!super');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.BANG);
-    expect(expression.operand, isNotNull);
-  }
-
-  void test_parseUnaryExpression_tilda_normal() {
-    PrefixExpression expression = parseUnaryExpression('~x');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.TILDE);
-    expect(expression.operand, isNotNull);
-  }
-
-  void test_parseUnaryExpression_tilda_super() {
-    PrefixExpression expression = parseUnaryExpression('~super');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.TILDE);
-    expect(expression.operand, isNotNull);
-  }
-
-  void test_parseUnaryExpression_tilde_identifier_index() {
-    PrefixExpression expression = parseExpression('~a[0]');
-    expect(expression, isNotNull);
-    assertNoErrors();
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.TILDE);
-    expect(expression.operand, isNotNull);
-    IndexExpression operand = expression.operand as IndexExpression;
-    expect(operand.realTarget, const TypeMatcher<SimpleIdentifier>());
-    expect(operand.index is IntegerLiteral, isTrue);
-  }
-}
-
-@reflectiveTest
-class ExtensionMethodsParserTest extends FastaParserTestCase {
-  void test_complex_extends() {
-    var unit = parseCompilationUnit(
-        'extension E extends A with B, C implements D { }',
-        errors: [
-          expectedError(ParserErrorCode.EXPECTED_INSTEAD, 12, 7),
-          expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 22, 4),
-          expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 28, 1),
-          expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 32, 10),
-        ]);
-    expect(unit.declarations, hasLength(1));
-    var extension = unit.declarations[0] as ExtensionDeclaration;
-    expect(extension.name.name, 'E');
-    expect(extension.onKeyword.lexeme, 'extends');
-    expect((extension.extendedType as NamedType).name.name, 'A');
-    expect(extension.members, hasLength(0));
-  }
-
-  void test_complex_implements() {
-    var unit = parseCompilationUnit('extension E implements C, D { }', errors: [
-      expectedError(ParserErrorCode.EXPECTED_INSTEAD, 12, 10),
-      expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 24, 1),
-    ]);
-    expect(unit.declarations, hasLength(1));
-    var extension = unit.declarations[0] as ExtensionDeclaration;
-    expect(extension.name.name, 'E');
-    expect(extension.onKeyword.lexeme, 'implements');
-    expect((extension.extendedType as NamedType).name.name, 'C');
-    expect(extension.members, hasLength(0));
-  }
-
-  void test_complex_type() {
-    var unit = parseCompilationUnit('extension E on C<T> { }');
-    expect(unit.declarations, hasLength(1));
-    var extension = unit.declarations[0] as ExtensionDeclaration;
-    expect(extension.name.name, 'E');
-    expect(extension.onKeyword.lexeme, 'on');
-    var namedType = extension.extendedType as NamedType;
-    expect(namedType.name.name, 'C');
-    expect(namedType.typeArguments.arguments, hasLength(1));
-    expect(extension.members, hasLength(0));
-  }
-
-  void test_complex_type2() {
-    var unit = parseCompilationUnit('extension E<T> on C<T> { }');
-    expect(unit.declarations, hasLength(1));
-    var extension = unit.declarations[0] as ExtensionDeclaration;
-    expect(extension.name.name, 'E');
-    expect(extension.onKeyword.lexeme, 'on');
-    var namedType = extension.extendedType as NamedType;
-    expect(namedType.name.name, 'C');
-    expect(namedType.typeArguments.arguments, hasLength(1));
-    expect(extension.members, hasLength(0));
-  }
-
-  void test_complex_type2_no_name() {
-    var unit = parseCompilationUnit('extension<T> on C<T> { }');
-    expect(unit.declarations, hasLength(1));
-    var extension = unit.declarations[0] as ExtensionDeclaration;
-    expect(extension.name, isNull);
-    expect(extension.onKeyword.lexeme, 'on');
-    var namedType = extension.extendedType as NamedType;
-    expect(namedType.name.name, 'C');
-    expect(namedType.typeArguments.arguments, hasLength(1));
-    expect(extension.members, hasLength(0));
-  }
-
-  void test_constructor_named() {
-    var unit = parseCompilationUnit('''
-extension E on C {
-  E.named();
-}
-class C {}
-''', errors: [
-      expectedError(ParserErrorCode.EXTENSION_DECLARES_CONSTRUCTOR, 21, 1),
-    ]);
-    expect(unit.declarations, hasLength(2));
-    var extension = unit.declarations[0] as ExtensionDeclaration;
-    expect(extension.members, hasLength(0));
-  }
-
-  void test_constructor_unnamed() {
-    var unit = parseCompilationUnit('''
-extension E on C {
-  E();
-}
-class C {}
-''', errors: [
-      expectedError(ParserErrorCode.EXTENSION_DECLARES_CONSTRUCTOR, 21, 1),
-    ]);
-    expect(unit.declarations, hasLength(2));
-    var extension = unit.declarations[0] as ExtensionDeclaration;
-    expect(extension.members, hasLength(0));
-  }
-
-  void test_missing_on() {
-    var unit = parseCompilationUnit('extension E', errors: [
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 10, 1),
-      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 11, 0),
-      expectedError(ParserErrorCode.EXPECTED_BODY, 11, 0),
-    ]);
-    expect(unit.declarations, hasLength(1));
-    var extension = unit.declarations[0] as ExtensionDeclaration;
-    expect(extension.name.name, 'E');
-    expect(extension.onKeyword.lexeme, 'on');
-    expect((extension.extendedType as NamedType).name.name, '');
-    expect(extension.members, hasLength(0));
-  }
-
-  void test_missing_on_withBlock() {
-    var unit = parseCompilationUnit('extension E {}', errors: [
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 10, 1),
-      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 12, 1),
-    ]);
-    expect(unit.declarations, hasLength(1));
-    var extension = unit.declarations[0] as ExtensionDeclaration;
-    expect(extension.name.name, 'E');
-    expect(extension.onKeyword.lexeme, 'on');
-    expect((extension.extendedType as NamedType).name.name, '');
-    expect(extension.members, hasLength(0));
-  }
-
-  void test_missing_on_withClassAndBlock() {
-    var unit = parseCompilationUnit('extension E C {}', errors: [
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 10, 1),
-    ]);
-    expect(unit.declarations, hasLength(1));
-    var extension = unit.declarations[0] as ExtensionDeclaration;
-    expect(extension.name.name, 'E');
-    expect(extension.onKeyword.lexeme, 'on');
-    expect((extension.extendedType as NamedType).name.name, 'C');
-    expect(extension.members, hasLength(0));
-  }
-
-  void test_parse_toplevel_member_called_late_calling_self() {
-    CompilationUnitImpl unit = parseCompilationUnit('void late() { late(); }',
-        featureSet: nonNullable);
-    FunctionDeclaration method = unit.declarations[0];
-
-    expect(method.documentationComment, isNull);
-    expect(method.externalKeyword, isNull);
-    expect(method.propertyKeyword, isNull);
-    expect(method.returnType, isNotNull);
-    expect(method.name.name, 'late');
-    expect(method.functionExpression, isNotNull);
-
-    BlockFunctionBody body = method.functionExpression.body;
-    ExpressionStatement statement = body.block.statements[0];
-    MethodInvocation invocation = statement.expression;
-    expect(invocation.operator, isNull);
-    expect(invocation.toSource(), 'late()');
-  }
-
-  void test_simple() {
-    var unit = parseCompilationUnit('extension E on C { }');
-    expect(unit.declarations, hasLength(1));
-    var extension = unit.declarations[0] as ExtensionDeclaration;
-    expect(extension.name.name, 'E');
-    expect(extension.onKeyword.lexeme, 'on');
-    expect((extension.extendedType as NamedType).name.name, 'C');
-    var namedType = extension.extendedType as NamedType;
-    expect(namedType.name.name, 'C');
-    expect(namedType.typeArguments, isNull);
-    expect(extension.members, hasLength(0));
-  }
-
-  void test_simple_extends() {
-    var unit = parseCompilationUnit('extension E extends C { }', errors: [
-      expectedError(ParserErrorCode.EXPECTED_INSTEAD, 12, 7),
-    ]);
-    expect(unit.declarations, hasLength(1));
-    var extension = unit.declarations[0] as ExtensionDeclaration;
-    expect(extension.name.name, 'E');
-    expect(extension.onKeyword.lexeme, 'extends');
-    expect((extension.extendedType as NamedType).name.name, 'C');
-    expect(extension.members, hasLength(0));
-  }
-
-  void test_simple_implements() {
-    var unit = parseCompilationUnit('extension E implements C { }', errors: [
-      expectedError(ParserErrorCode.EXPECTED_INSTEAD, 12, 10),
-    ]);
-    expect(unit.declarations, hasLength(1));
-    var extension = unit.declarations[0] as ExtensionDeclaration;
-    expect(extension.name.name, 'E');
-    expect(extension.onKeyword.lexeme, 'implements');
-    expect((extension.extendedType as NamedType).name.name, 'C');
-    expect(extension.members, hasLength(0));
-  }
-
-  void test_simple_no_name() {
-    var unit = parseCompilationUnit('extension on C { }');
-    expect(unit.declarations, hasLength(1));
-    var extension = unit.declarations[0] as ExtensionDeclaration;
-    expect(extension.name, isNull);
-    expect(extension.onKeyword.lexeme, 'on');
-    expect((extension.extendedType as NamedType).name.name, 'C');
-    var namedType = extension.extendedType as NamedType;
-    expect(namedType.name.name, 'C');
-    expect(namedType.typeArguments, isNull);
-    expect(extension.members, hasLength(0));
-  }
-
-  void test_simple_not_enabled() {
-    parseCompilationUnit(
-      'extension E on C { }',
-      errors: [
-        expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 0, 9),
-        expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 15, 1)
-      ],
-      featureSet: FeatureSet.fromEnableFlags2(
-        sdkLanguageVersion: Version.parse('2.3.0'),
-        flags: [],
-      ),
-    );
-  }
-
-  void test_simple_with() {
-    var unit = parseCompilationUnit('extension E with C { }', errors: [
-      expectedError(ParserErrorCode.EXPECTED_INSTEAD, 12, 4),
-    ]);
-    expect(unit.declarations, hasLength(1));
-    var extension = unit.declarations[0] as ExtensionDeclaration;
-    expect(extension.name.name, 'E');
-    expect(extension.onKeyword.lexeme, 'with');
-    expect((extension.extendedType as NamedType).name.name, 'C');
-    expect(extension.members, hasLength(0));
-  }
-
-  void test_void_type() {
-    var unit = parseCompilationUnit('extension E on void { }');
-    expect(unit.declarations, hasLength(1));
-    var extension = unit.declarations[0] as ExtensionDeclaration;
-    expect(extension.name.name, 'E');
-    expect(extension.onKeyword.lexeme, 'on');
-    expect((extension.extendedType as NamedType).name.name, 'void');
-    expect(extension.members, hasLength(0));
-  }
-}
-
-/// The class [FormalParameterParserTestMixin] defines parser tests that test
-/// the parsing of formal parameters.
-@reflectiveTest
-class FormalParameterParserTest extends FastaParserTestCase {
-  FormalParameter parseNNBDFormalParameter(String code, ParameterKind kind,
-      {List<ExpectedError> errors}) {
-    String parametersCode;
-    if (kind == ParameterKind.REQUIRED) {
-      parametersCode = '($code)';
-    } else if (kind == ParameterKind.POSITIONAL) {
-      parametersCode = '([$code])';
-    } else if (kind == ParameterKind.NAMED) {
-      parametersCode = '({$code})';
-    } else {
-      fail('$kind');
-    }
-    createParser(parametersCode, featureSet: nonNullable);
-    FormalParameterList list =
-        parserProxy.parseFormalParameterList(inFunctionType: false);
-    assertErrors(errors: errors);
-    return list.parameters.single;
-  }
-
-  void test_fieldFormalParameter_function_nullable() {
-    var parameter =
-        parseNNBDFormalParameter('void this.a()?', ParameterKind.REQUIRED);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isFieldFormalParameter);
-    FieldFormalParameter functionParameter = parameter;
-    expect(functionParameter.type, isNotNull);
-    expect(functionParameter.identifier, isNotNull);
-    expect(functionParameter.typeParameters, isNull);
-    expect(functionParameter.parameters, isNotNull);
-    expect(functionParameter.question, isNotNull);
-    expect(functionParameter.endToken, functionParameter.question);
-  }
-
-  void test_functionTyped_named_nullable() {
-    ParameterKind kind = ParameterKind.NAMED;
-    var defaultParameter =
-        parseNNBDFormalParameter('a()? : null', kind) as DefaultFormalParameter;
-    var functionParameter =
-        defaultParameter.parameter as FunctionTypedFormalParameter;
-    assertNoErrors();
-    expect(functionParameter.returnType, isNull);
-    expect(functionParameter.identifier, isNotNull);
-    expect(functionParameter.typeParameters, isNull);
-    expect(functionParameter.parameters, isNotNull);
-    expect(functionParameter.isNamed, isTrue);
-    expect(functionParameter.question, isNotNull);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isNamed, isTrue);
-  }
-
-  void test_functionTyped_named_nullable_disabled() {
-    ParameterKind kind = ParameterKind.NAMED;
-    var defaultParameter = parseFormalParameter('a()? : null', kind,
-            featureSet: preNonNullable,
-            errorCodes: [ParserErrorCode.EXPERIMENT_NOT_ENABLED])
-        as DefaultFormalParameter;
-    var functionParameter =
-        defaultParameter.parameter as FunctionTypedFormalParameter;
-    expect(functionParameter.returnType, isNull);
-    expect(functionParameter.identifier, isNotNull);
-    expect(functionParameter.typeParameters, isNull);
-    expect(functionParameter.parameters, isNotNull);
-    expect(functionParameter.isNamed, isTrue);
-    expect(functionParameter.question, isNotNull);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isNamed, isTrue);
-  }
-
-  void test_functionTyped_positional_nullable_disabled() {
-    ParameterKind kind = ParameterKind.POSITIONAL;
-    var defaultParameter = parseFormalParameter('a()? = null', kind,
-            featureSet: preNonNullable,
-            errorCodes: [ParserErrorCode.EXPERIMENT_NOT_ENABLED])
-        as DefaultFormalParameter;
-    var functionParameter =
-        defaultParameter.parameter as FunctionTypedFormalParameter;
-    expect(functionParameter.returnType, isNull);
-    expect(functionParameter.identifier, isNotNull);
-    expect(functionParameter.typeParameters, isNull);
-    expect(functionParameter.parameters, isNotNull);
-    expect(functionParameter.isOptionalPositional, isTrue);
-    expect(functionParameter.question, isNotNull);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isOptionalPositional, isTrue);
-  }
-
-  void test_functionTyped_required_nullable_disabled() {
-    ParameterKind kind = ParameterKind.REQUIRED;
-    var functionParameter = parseFormalParameter('a()?', kind,
-            featureSet: preNonNullable,
-            errorCodes: [ParserErrorCode.EXPERIMENT_NOT_ENABLED])
-        as FunctionTypedFormalParameter;
-    expect(functionParameter.returnType, isNull);
-    expect(functionParameter.identifier, isNotNull);
-    expect(functionParameter.typeParameters, isNull);
-    expect(functionParameter.parameters, isNotNull);
-    expect(functionParameter.isRequiredPositional, isTrue);
-    expect(functionParameter.question, isNotNull);
-  }
-
-  void test_parseConstructorParameter_this() {
-    parseCompilationUnit('''
-class C {
-  final int field;
-  C(this.field);
-}''');
-  }
-
-  void test_parseConstructorParameter_this_Function() {
-    parseCompilationUnit('''
-class C {
-  final Object Function(int, double) field;
-  C(String Function(num, Object) this.field);
-}''');
-  }
-
-  void test_parseConstructorParameter_this_int() {
-    parseCompilationUnit('''
-class C {
-  final int field;
-  C(int this.field);
-}''');
-  }
-
-  void test_parseFormalParameter_covariant_final_named() {
-    ParameterKind kind = ParameterKind.NAMED;
-    FormalParameter parameter =
-        parseFormalParameter('covariant final a : null', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNotNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.isNamed, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isNamed, isTrue);
-  }
-
-  void test_parseFormalParameter_covariant_final_normal() {
-    ParameterKind kind = ParameterKind.REQUIRED;
-    FormalParameter parameter = parseFormalParameter('covariant final a', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isSimpleFormalParameter);
-    SimpleFormalParameter simpleParameter = parameter;
-    expect(simpleParameter.covariantKeyword, isNotNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.isRequired, isTrue);
-  }
-
-  void test_parseFormalParameter_covariant_final_positional() {
-    ParameterKind kind = ParameterKind.POSITIONAL;
-    FormalParameter parameter =
-        parseFormalParameter('covariant final a = null', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNotNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.isOptionalPositional, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isOptionalPositional, isTrue);
-  }
-
-  void test_parseFormalParameter_covariant_final_type_named() {
-    ParameterKind kind = ParameterKind.NAMED;
-    FormalParameter parameter =
-        parseFormalParameter('covariant final A a : null', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNotNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.isNamed, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isNamed, isTrue);
-  }
-
-  void test_parseFormalParameter_covariant_final_type_normal() {
-    ParameterKind kind = ParameterKind.REQUIRED;
-    FormalParameter parameter =
-        parseFormalParameter('covariant final A a', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isSimpleFormalParameter);
-    SimpleFormalParameter simpleParameter = parameter;
-    expect(simpleParameter.covariantKeyword, isNotNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.isRequired, isTrue);
-  }
-
-  void test_parseFormalParameter_covariant_final_type_positional() {
-    ParameterKind kind = ParameterKind.POSITIONAL;
-    FormalParameter parameter =
-        parseFormalParameter('covariant final A a = null', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNotNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.isOptionalPositional, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isOptionalPositional, isTrue);
-  }
-
-  void test_parseFormalParameter_covariant_required_named() {
-    ParameterKind kind = ParameterKind.NAMED;
-    FormalParameter parameter = parseNNBDFormalParameter(
-        'covariant required A a : null', kind,
-        errors: [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 12, 8)]);
-    expect(parameter, isNotNull);
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNotNull);
-    expect(simpleParameter.requiredKeyword, isNotNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.isNamed, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isNamed, isTrue);
-  }
-
-  void test_parseFormalParameter_covariant_type_function() {
-    ParameterKind kind = ParameterKind.REQUIRED;
-    FormalParameter parameter =
-        parseFormalParameter('covariant String Function(int) a', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isSimpleFormalParameter);
-    SimpleFormalParameter simpleParameter = parameter;
-    expect(simpleParameter.covariantKeyword, isNotNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, isGenericFunctionType);
-    expect(simpleParameter.isRequired, isTrue);
-  }
-
-  void test_parseFormalParameter_covariant_type_named() {
-    ParameterKind kind = ParameterKind.NAMED;
-    FormalParameter parameter =
-        parseFormalParameter('covariant A a : null', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNotNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.isNamed, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isNamed, isTrue);
-  }
-
-  void test_parseFormalParameter_covariant_type_normal() {
-    ParameterKind kind = ParameterKind.REQUIRED;
-    FormalParameter parameter =
-        parseFormalParameter('covariant A<B<C>> a', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isSimpleFormalParameter);
-    SimpleFormalParameter simpleParameter = parameter;
-    expect(simpleParameter.covariantKeyword, isNotNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.isRequired, isTrue);
-  }
-
-  void test_parseFormalParameter_covariant_type_positional() {
-    ParameterKind kind = ParameterKind.POSITIONAL;
-    FormalParameter parameter =
-        parseFormalParameter('covariant A a = null', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNotNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.isOptionalPositional, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isOptionalPositional, isTrue);
-  }
-
-  void test_parseFormalParameter_covariant_var_named() {
-    ParameterKind kind = ParameterKind.NAMED;
-    FormalParameter parameter =
-        parseFormalParameter('covariant var a : null', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNotNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.isNamed, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isNamed, isTrue);
-  }
-
-  void test_parseFormalParameter_covariant_var_normal() {
-    ParameterKind kind = ParameterKind.REQUIRED;
-    FormalParameter parameter = parseFormalParameter('covariant var a', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isSimpleFormalParameter);
-    SimpleFormalParameter simpleParameter = parameter;
-    expect(simpleParameter.covariantKeyword, isNotNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.isRequired, isTrue);
-  }
-
-  void test_parseFormalParameter_covariant_var_positional() {
-    ParameterKind kind = ParameterKind.POSITIONAL;
-    FormalParameter parameter =
-        parseFormalParameter('covariant var a = null', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNotNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.isOptionalPositional, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isOptionalPositional, isTrue);
-  }
-
-  void test_parseFormalParameter_external() {
-    parseNNBDFormalParameter('external int i', ParameterKind.REQUIRED, errors: [
-      expectedError(ParserErrorCode.EXTRANEOUS_MODIFIER, 1, 8),
-    ]);
-  }
-
-  void test_parseFormalParameter_final_named() {
-    ParameterKind kind = ParameterKind.NAMED;
-    FormalParameter parameter = parseFormalParameter('final a : null', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.isNamed, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isNamed, isTrue);
-  }
-
-  void test_parseFormalParameter_final_normal() {
-    ParameterKind kind = ParameterKind.REQUIRED;
-    FormalParameter parameter = parseFormalParameter('final a', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isSimpleFormalParameter);
-    SimpleFormalParameter simpleParameter = parameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.isRequired, isTrue);
-  }
-
-  void test_parseFormalParameter_final_positional() {
-    ParameterKind kind = ParameterKind.POSITIONAL;
-    FormalParameter parameter = parseFormalParameter('final a = null', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.isOptionalPositional, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isOptionalPositional, isTrue);
-  }
-
-  void test_parseFormalParameter_final_required_named() {
-    ParameterKind kind = ParameterKind.NAMED;
-    FormalParameter parameter = parseNNBDFormalParameter(
-        'final required a : null', kind,
-        errors: [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 8, 8)]);
-    expect(parameter, isNotNull);
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.requiredKeyword, isNotNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.isNamed, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isNamed, isTrue);
-  }
-
-  void test_parseFormalParameter_final_type_named() {
-    ParameterKind kind = ParameterKind.NAMED;
-    FormalParameter parameter = parseFormalParameter('final A a : null', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.isNamed, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isNamed, isTrue);
-  }
-
-  void test_parseFormalParameter_final_type_normal() {
-    ParameterKind kind = ParameterKind.REQUIRED;
-    FormalParameter parameter = parseFormalParameter('final A a', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isSimpleFormalParameter);
-    SimpleFormalParameter simpleParameter = parameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.isRequired, isTrue);
-  }
-
-  void test_parseFormalParameter_final_type_positional() {
-    ParameterKind kind = ParameterKind.POSITIONAL;
-    FormalParameter parameter = parseFormalParameter('final A a = null', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.isOptionalPositional, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isOptionalPositional, isTrue);
-  }
-
-  void test_parseFormalParameter_required_covariant_named() {
-    ParameterKind kind = ParameterKind.NAMED;
-    FormalParameter parameter =
-        parseNNBDFormalParameter('required covariant A a : null', kind);
-    expect(parameter, isNotNull);
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNotNull);
-    expect(simpleParameter.requiredKeyword, isNotNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.isNamed, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isNamed, isTrue);
-  }
-
-  void test_parseFormalParameter_required_final_named() {
-    ParameterKind kind = ParameterKind.NAMED;
-    FormalParameter parameter =
-        parseNNBDFormalParameter('required final a : null', kind);
-    expect(parameter, isNotNull);
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.requiredKeyword, isNotNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.isNamed, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isNamed, isTrue);
-  }
-
-  void test_parseFormalParameter_required_type_named() {
-    ParameterKind kind = ParameterKind.NAMED;
-    FormalParameter parameter =
-        parseNNBDFormalParameter('required A a : null', kind);
-    expect(parameter, isNotNull);
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.requiredKeyword, isNotNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.isNamed, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isNamed, isTrue);
-  }
-
-  void test_parseFormalParameter_required_var_named() {
-    ParameterKind kind = ParameterKind.NAMED;
-    FormalParameter parameter =
-        parseNNBDFormalParameter('required var a : null', kind);
-    expect(parameter, isNotNull);
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.requiredKeyword, isNotNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.isNamed, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isNamed, isTrue);
-  }
-
-  void test_parseFormalParameter_type_function() {
-    ParameterKind kind = ParameterKind.REQUIRED;
-    FormalParameter parameter =
-        parseFormalParameter('String Function(int) a', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isSimpleFormalParameter);
-    SimpleFormalParameter simpleParameter = parameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, isGenericFunctionType);
-    expect(simpleParameter.isRequired, isTrue);
-  }
-
-  void test_parseFormalParameter_type_named() {
-    ParameterKind kind = ParameterKind.NAMED;
-    FormalParameter parameter = parseFormalParameter('A a : null', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.isNamed, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isNamed, isTrue);
-  }
-
-  void test_parseFormalParameter_type_named_noDefault() {
-    ParameterKind kind = ParameterKind.NAMED;
-    FormalParameter parameter = parseFormalParameter('A a', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.isNamed, isTrue);
-    expect(defaultParameter.separator, isNull);
-    expect(defaultParameter.defaultValue, isNull);
-    expect(defaultParameter.isNamed, isTrue);
-  }
-
-  void test_parseFormalParameter_type_normal() {
-    ParameterKind kind = ParameterKind.REQUIRED;
-    FormalParameter parameter = parseFormalParameter('A a', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isSimpleFormalParameter);
-    SimpleFormalParameter simpleParameter = parameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.isRequired, isTrue);
-  }
-
-  void test_parseFormalParameter_type_positional() {
-    ParameterKind kind = ParameterKind.POSITIONAL;
-    FormalParameter parameter = parseFormalParameter('A a = null', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.isOptionalPositional, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isOptionalPositional, isTrue);
-  }
-
-  void test_parseFormalParameter_type_positional_noDefault() {
-    ParameterKind kind = ParameterKind.POSITIONAL;
-    FormalParameter parameter = parseFormalParameter('A a', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.isOptionalPositional, isTrue);
-    expect(defaultParameter.separator, isNull);
-    expect(defaultParameter.defaultValue, isNull);
-    expect(defaultParameter.isOptionalPositional, isTrue);
-  }
-
-  void test_parseFormalParameter_var_named() {
-    ParameterKind kind = ParameterKind.NAMED;
-    FormalParameter parameter = parseFormalParameter('var a : null', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.isNamed, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isNamed, isTrue);
-  }
-
-  void test_parseFormalParameter_var_normal() {
-    ParameterKind kind = ParameterKind.REQUIRED;
-    FormalParameter parameter = parseFormalParameter('var a', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isSimpleFormalParameter);
-    SimpleFormalParameter simpleParameter = parameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.isRequired, isTrue);
-  }
-
-  void test_parseFormalParameter_var_positional() {
-    ParameterKind kind = ParameterKind.POSITIONAL;
-    FormalParameter parameter = parseFormalParameter('var a = null', kind);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.requiredKeyword, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.isOptionalPositional, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isOptionalPositional, isTrue);
-  }
-
-  void test_parseFormalParameter_var_required_named() {
-    ParameterKind kind = ParameterKind.NAMED;
-    FormalParameter parameter = parseNNBDFormalParameter(
-        'var required a : null', kind,
-        errors: [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 6, 8)]);
-    expect(parameter, isNotNull);
-    expect(parameter, isDefaultFormalParameter);
-    DefaultFormalParameter defaultParameter = parameter;
-    SimpleFormalParameter simpleParameter =
-        defaultParameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.requiredKeyword, isNotNull);
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.isNamed, isTrue);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isNamed, isTrue);
-  }
-
-  void test_parseFormalParameterList_empty() {
-    FormalParameterList list = parseFormalParameterList('()');
-    expect(list, isNotNull);
-    assertNoErrors();
-    expect(list.leftParenthesis, isNotNull);
-    expect(list.leftDelimiter, isNull);
-    expect(list.parameters, hasLength(0));
-    expect(list.rightDelimiter, isNull);
-    expect(list.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_named_multiple() {
-    FormalParameterList list =
-        parseFormalParameterList('({A a : 1, B b, C c : 3})');
-    expect(list, isNotNull);
-    assertNoErrors();
-    expect(list.leftParenthesis, isNotNull);
-    expect(list.leftDelimiter, isNotNull);
-    expect(list.parameters, hasLength(3));
-    expect(list.rightDelimiter, isNotNull);
-    expect(list.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_named_single() {
-    FormalParameterList list = parseFormalParameterList('({A a})');
-    expect(list, isNotNull);
-    assertNoErrors();
-    expect(list.leftParenthesis, isNotNull);
-    expect(list.leftDelimiter, isNotNull);
-    expect(list.parameters, hasLength(1));
-    expect(list.rightDelimiter, isNotNull);
-    expect(list.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_named_trailing_comma() {
-    FormalParameterList list = parseFormalParameterList('(A a, {B b,})');
-    expect(list, isNotNull);
-    assertNoErrors();
-    expect(list.leftParenthesis, isNotNull);
-    expect(list.leftDelimiter, isNotNull);
-    expect(list.parameters, hasLength(2));
-    expect(list.rightDelimiter, isNotNull);
-    expect(list.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_normal_multiple() {
-    FormalParameterList list = parseFormalParameterList('(A a, B b, C c)');
-    expect(list, isNotNull);
-    assertNoErrors();
-    expect(list.leftParenthesis, isNotNull);
-    expect(list.leftDelimiter, isNull);
-    expect(list.parameters, hasLength(3));
-    expect(list.rightDelimiter, isNull);
-    expect(list.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_normal_named() {
-    FormalParameterList list = parseFormalParameterList('(A a, {B b})');
-    expect(list, isNotNull);
-    assertNoErrors();
-    expect(list.leftParenthesis, isNotNull);
-    expect(list.leftDelimiter, isNotNull);
-    expect(list.parameters, hasLength(2));
-    expect(list.rightDelimiter, isNotNull);
-    expect(list.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_normal_named_inFunctionType() {
-    FormalParameterList list =
-        parseFormalParameterList('(A, {B b})', inFunctionType: true);
-    expect(list, isNotNull);
-    assertNoErrors();
-    expect(list.leftParenthesis, isNotNull);
-    expect(list.leftDelimiter, isNotNull);
-    expect(list.rightDelimiter, isNotNull);
-    expect(list.rightParenthesis, isNotNull);
-    NodeList<FormalParameter> parameters = list.parameters;
-    expect(parameters, hasLength(2));
-
-    expect(parameters[0], isSimpleFormalParameter);
-    SimpleFormalParameter required = parameters[0];
-    expect(required.identifier, isNull);
-    expect(required.type, isTypeName);
-    expect((required.type as TypeName).name.name, 'A');
-
-    expect(parameters[1], isDefaultFormalParameter);
-    DefaultFormalParameter named = parameters[1];
-    expect(named.identifier, isNotNull);
-    expect(named.parameter, isSimpleFormalParameter);
-    SimpleFormalParameter simple = named.parameter;
-    expect(simple.type, isTypeName);
-    expect((simple.type as TypeName).name.name, 'B');
-  }
-
-  void test_parseFormalParameterList_normal_positional() {
-    FormalParameterList list = parseFormalParameterList('(A a, [B b])');
-    expect(list, isNotNull);
-    assertNoErrors();
-    expect(list.leftParenthesis, isNotNull);
-    expect(list.leftDelimiter, isNotNull);
-    expect(list.parameters, hasLength(2));
-    expect(list.rightDelimiter, isNotNull);
-    expect(list.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_normal_single() {
-    FormalParameterList list = parseFormalParameterList('(A a)');
-    expect(list, isNotNull);
-    assertNoErrors();
-    expect(list.leftParenthesis, isNotNull);
-    expect(list.leftDelimiter, isNull);
-    expect(list.parameters, hasLength(1));
-    expect(list.rightDelimiter, isNull);
-    expect(list.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_normal_single_Function() {
-    FormalParameterList list = parseFormalParameterList('(Function f)');
-    expect(list, isNotNull);
-    assertNoErrors();
-    expect(list.leftParenthesis, isNotNull);
-    expect(list.leftDelimiter, isNull);
-    expect(list.parameters, hasLength(1));
-    expect(list.rightDelimiter, isNull);
-    expect(list.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_normal_single_trailing_comma() {
-    FormalParameterList list = parseFormalParameterList('(A a,)');
-    expect(list, isNotNull);
-    assertNoErrors();
-    expect(list.leftParenthesis, isNotNull);
-    expect(list.leftDelimiter, isNull);
-    expect(list.parameters, hasLength(1));
-    expect(list.rightDelimiter, isNull);
-    expect(list.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_positional_multiple() {
-    FormalParameterList list =
-        parseFormalParameterList('([A a = null, B b, C c = null])');
-    expect(list, isNotNull);
-    assertNoErrors();
-    expect(list.leftParenthesis, isNotNull);
-    expect(list.leftDelimiter, isNotNull);
-    expect(list.parameters, hasLength(3));
-    expect(list.rightDelimiter, isNotNull);
-    expect(list.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_positional_single() {
-    FormalParameterList list = parseFormalParameterList('([A a = null])');
-    expect(list, isNotNull);
-    assertNoErrors();
-    expect(list.leftParenthesis, isNotNull);
-    expect(list.leftDelimiter, isNotNull);
-    expect(list.parameters, hasLength(1));
-    expect(list.rightDelimiter, isNotNull);
-    expect(list.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_positional_trailing_comma() {
-    FormalParameterList list = parseFormalParameterList('(A a, [B b,])');
-    expect(list, isNotNull);
-    assertNoErrors();
-    expect(list.leftParenthesis, isNotNull);
-    expect(list.leftDelimiter, isNotNull);
-    expect(list.parameters, hasLength(2));
-    expect(list.rightDelimiter, isNotNull);
-    expect(list.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_prefixedType() {
-    FormalParameterList list = parseFormalParameterList('(io.File f)');
-    expect(list, isNotNull);
-    assertNoErrors();
-    expect(list.leftParenthesis, isNotNull);
-    expect(list.leftDelimiter, isNull);
-    expect(list.parameters, hasLength(1));
-    expect(list.parameters[0].toSource(), 'io.File f');
-    expect(list.rightDelimiter, isNull);
-    expect(list.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_prefixedType_missingName() {
-    FormalParameterList list = parseFormalParameterList('(io.File)',
-        errors: [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 1)]);
-    expect(list, isNotNull);
-    expect(list.leftParenthesis, isNotNull);
-    expect(list.leftDelimiter, isNull);
-    expect(list.parameters, hasLength(1));
-    // TODO(danrubel): Investigate and improve recovery of parameter type/name.
-    SimpleFormalParameter parameter = list.parameters[0];
-    expect(parameter.toSource(), 'io.File ');
-    expect(parameter.identifier.token.isSynthetic, isTrue);
-    TypeName type = parameter.type;
-    PrefixedIdentifier typeName = type.name;
-    expect(typeName.prefix.token.isSynthetic, isFalse);
-    expect(typeName.identifier.token.isSynthetic, isFalse);
-    expect(list.rightDelimiter, isNull);
-    expect(list.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_prefixedType_partial() {
-    FormalParameterList list = parseFormalParameterList('(io.)', errors: [
-      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 4, 1),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 4, 1)
-    ]);
-    expect(list, isNotNull);
-    expect(list.leftParenthesis, isNotNull);
-    expect(list.leftDelimiter, isNull);
-    expect(list.parameters, hasLength(1));
-    // TODO(danrubel): Investigate and improve recovery of parameter type/name.
-    SimpleFormalParameter parameter = list.parameters[0];
-    expect(parameter.toSource(), 'io. ');
-    expect(parameter.identifier.token.isSynthetic, isTrue);
-    TypeName type = parameter.type;
-    PrefixedIdentifier typeName = type.name;
-    expect(typeName.prefix.token.isSynthetic, isFalse);
-    expect(typeName.identifier.token.isSynthetic, isTrue);
-    expect(list.rightDelimiter, isNull);
-    expect(list.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_prefixedType_partial2() {
-    FormalParameterList list = parseFormalParameterList('(io.,a)', errors: [
-      expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 4, 1),
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 4, 1)
-    ]);
-    expect(list, isNotNull);
-    expect(list.leftParenthesis, isNotNull);
-    expect(list.leftDelimiter, isNull);
-    expect(list.parameters, hasLength(2));
-    expect(list.parameters[0].toSource(), 'io. ');
-    expect(list.parameters[1].toSource(), 'a');
-    expect(list.rightDelimiter, isNull);
-    expect(list.rightParenthesis, isNotNull);
-  }
-
-  void test_parseNormalFormalParameter_field_const_noType() {
-    NormalFormalParameter parameter = parseNormalFormalParameter('const this.a',
-        errorCodes: [ParserErrorCode.EXTRANEOUS_MODIFIER]);
-    expect(parameter, isNotNull);
-    expect(parameter, isFieldFormalParameter);
-    FieldFormalParameter fieldParameter = parameter;
-    expect(fieldParameter.keyword, isNotNull);
-    expect(fieldParameter.type, isNull);
-    expect(fieldParameter.identifier, isNotNull);
-    expect(fieldParameter.parameters, isNull);
-  }
-
-  void test_parseNormalFormalParameter_field_const_type() {
-    NormalFormalParameter parameter = parseNormalFormalParameter(
-        'const A this.a',
-        errorCodes: [ParserErrorCode.EXTRANEOUS_MODIFIER]);
-    expect(parameter, isNotNull);
-    expect(parameter, isFieldFormalParameter);
-    FieldFormalParameter fieldParameter = parameter;
-    expect(fieldParameter.keyword, isNotNull);
-    expect(fieldParameter.type, isNotNull);
-    expect(fieldParameter.identifier, isNotNull);
-    expect(fieldParameter.parameters, isNull);
-  }
-
-  void test_parseNormalFormalParameter_field_final_noType() {
-    NormalFormalParameter parameter =
-        parseNormalFormalParameter('final this.a');
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isFieldFormalParameter);
-    FieldFormalParameter fieldParameter = parameter;
-    expect(fieldParameter.keyword, isNotNull);
-    expect(fieldParameter.type, isNull);
-    expect(fieldParameter.identifier, isNotNull);
-    expect(fieldParameter.parameters, isNull);
-  }
-
-  void test_parseNormalFormalParameter_field_final_type() {
-    NormalFormalParameter parameter =
-        parseNormalFormalParameter('final A this.a');
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isFieldFormalParameter);
-    FieldFormalParameter fieldParameter = parameter;
-    expect(fieldParameter.keyword, isNotNull);
-    expect(fieldParameter.type, isNotNull);
-    expect(fieldParameter.identifier, isNotNull);
-    expect(fieldParameter.parameters, isNull);
-  }
-
-  void test_parseNormalFormalParameter_field_function_nested() {
-    NormalFormalParameter parameter = parseNormalFormalParameter('this.a(B b)');
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isFieldFormalParameter);
-    FieldFormalParameter fieldParameter = parameter;
-    expect(fieldParameter.keyword, isNull);
-    expect(fieldParameter.type, isNull);
-    expect(fieldParameter.identifier, isNotNull);
-    FormalParameterList parameterList = fieldParameter.parameters;
-    expect(parameterList, isNotNull);
-    expect(parameterList.parameters, hasLength(1));
-  }
-
-  void test_parseNormalFormalParameter_field_function_noNested() {
-    NormalFormalParameter parameter = parseNormalFormalParameter('this.a()');
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isFieldFormalParameter);
-    FieldFormalParameter fieldParameter = parameter;
-    expect(fieldParameter.keyword, isNull);
-    expect(fieldParameter.type, isNull);
-    expect(fieldParameter.identifier, isNotNull);
-    FormalParameterList parameterList = fieldParameter.parameters;
-    expect(parameterList, isNotNull);
-    expect(parameterList.parameters, hasLength(0));
-  }
-
-  void test_parseNormalFormalParameter_field_function_withDocComment() {
-    var parameter = parseNormalFormalParameter('/// Doc\nthis.f()');
-    expectCommentText(parameter.documentationComment, '/// Doc');
-  }
-
-  void test_parseNormalFormalParameter_field_noType() {
-    NormalFormalParameter parameter = parseNormalFormalParameter('this.a');
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isFieldFormalParameter);
-    FieldFormalParameter fieldParameter = parameter;
-    expect(fieldParameter.keyword, isNull);
-    expect(fieldParameter.type, isNull);
-    expect(fieldParameter.identifier, isNotNull);
-    expect(fieldParameter.parameters, isNull);
-  }
-
-  void test_parseNormalFormalParameter_field_type() {
-    NormalFormalParameter parameter = parseNormalFormalParameter('A this.a');
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isFieldFormalParameter);
-    FieldFormalParameter fieldParameter = parameter;
-    expect(fieldParameter.keyword, isNull);
-    expect(fieldParameter.type, isNotNull);
-    expect(fieldParameter.identifier, isNotNull);
-    expect(fieldParameter.parameters, isNull);
-  }
-
-  void test_parseNormalFormalParameter_field_var() {
-    NormalFormalParameter parameter = parseNormalFormalParameter('var this.a');
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isFieldFormalParameter);
-    FieldFormalParameter fieldParameter = parameter;
-    expect(fieldParameter.keyword, isNotNull);
-    expect(fieldParameter.type, isNull);
-    expect(fieldParameter.identifier, isNotNull);
-    expect(fieldParameter.parameters, isNull);
-  }
-
-  void test_parseNormalFormalParameter_field_withDocComment() {
-    var parameter = parseNormalFormalParameter('/// Doc\nthis.a');
-    expectCommentText(parameter.documentationComment, '/// Doc');
-  }
-
-  void test_parseNormalFormalParameter_function_named() {
-    ParameterKind kind = ParameterKind.NAMED;
-    var defaultParameter =
-        parseFormalParameter('a() : null', kind) as DefaultFormalParameter;
-    var functionParameter =
-        defaultParameter.parameter as FunctionTypedFormalParameter;
-    assertNoErrors();
-    expect(functionParameter.returnType, isNull);
-    expect(functionParameter.identifier, isNotNull);
-    expect(functionParameter.typeParameters, isNull);
-    expect(functionParameter.parameters, isNotNull);
-    expect(functionParameter.isNamed, isTrue);
-    expect(functionParameter.question, isNull);
-    expect(defaultParameter.separator, isNotNull);
-    expect(defaultParameter.defaultValue, isNotNull);
-    expect(defaultParameter.isNamed, isTrue);
-  }
-
-  void test_parseNormalFormalParameter_function_noType() {
-    NormalFormalParameter parameter = parseNormalFormalParameter('a()');
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isFunctionTypedFormalParameter);
-    FunctionTypedFormalParameter functionParameter = parameter;
-    expect(functionParameter.returnType, isNull);
-    expect(functionParameter.identifier, isNotNull);
-    expect(functionParameter.typeParameters, isNull);
-    expect(functionParameter.parameters, isNotNull);
-    expect(functionParameter.question, isNull);
-  }
-
-  void test_parseNormalFormalParameter_function_noType_covariant() {
-    NormalFormalParameter parameter =
-        parseNormalFormalParameter('covariant a()');
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isFunctionTypedFormalParameter);
-    FunctionTypedFormalParameter functionParameter = parameter;
-    expect(functionParameter.covariantKeyword, isNotNull);
-    expect(functionParameter.returnType, isNull);
-    expect(functionParameter.identifier, isNotNull);
-    expect(functionParameter.typeParameters, isNull);
-    expect(functionParameter.parameters, isNotNull);
-    expect(functionParameter.question, isNull);
-  }
-
-  void test_parseNormalFormalParameter_function_noType_nullable() {
-    NormalFormalParameter parameter =
-        parseNNBDFormalParameter('a()?', ParameterKind.REQUIRED);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isFunctionTypedFormalParameter);
-    FunctionTypedFormalParameter functionParameter = parameter;
-    expect(functionParameter.returnType, isNull);
-    expect(functionParameter.identifier, isNotNull);
-    expect(functionParameter.typeParameters, isNull);
-    expect(functionParameter.parameters, isNotNull);
-    expect(functionParameter.question, isNotNull);
-    expect(functionParameter.endToken, functionParameter.question);
-  }
-
-  void test_parseNormalFormalParameter_function_noType_typeParameters() {
-    NormalFormalParameter parameter = parseNormalFormalParameter('a<E>()');
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isFunctionTypedFormalParameter);
-    FunctionTypedFormalParameter functionParameter = parameter;
-    expect(functionParameter.returnType, isNull);
-    expect(functionParameter.identifier, isNotNull);
-    expect(functionParameter.typeParameters, isNotNull);
-    expect(functionParameter.parameters, isNotNull);
-    expect(functionParameter.question, isNull);
-  }
-
-  void test_parseNormalFormalParameter_function_type() {
-    NormalFormalParameter parameter = parseNormalFormalParameter('A a()');
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isFunctionTypedFormalParameter);
-    FunctionTypedFormalParameter functionParameter = parameter;
-    expect(functionParameter.returnType, isNotNull);
-    expect(functionParameter.identifier, isNotNull);
-    expect(functionParameter.typeParameters, isNull);
-    expect(functionParameter.parameters, isNotNull);
-    expect(functionParameter.question, isNull);
-  }
-
-  void test_parseNormalFormalParameter_function_type_typeParameters() {
-    NormalFormalParameter parameter = parseNormalFormalParameter('A a<E>()');
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isFunctionTypedFormalParameter);
-    FunctionTypedFormalParameter functionParameter = parameter;
-    expect(functionParameter.returnType, isNotNull);
-    expect(functionParameter.identifier, isNotNull);
-    expect(functionParameter.typeParameters, isNotNull);
-    expect(functionParameter.parameters, isNotNull);
-    expect(functionParameter.question, isNull);
-  }
-
-  void test_parseNormalFormalParameter_function_typeVoid_covariant() {
-    NormalFormalParameter parameter =
-        parseNormalFormalParameter('covariant void a()');
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isFunctionTypedFormalParameter);
-    FunctionTypedFormalParameter functionParameter = parameter;
-    expect(functionParameter.covariantKeyword, isNotNull);
-    expect(functionParameter.returnType, isNotNull);
-    expect(functionParameter.identifier, isNotNull);
-    expect(functionParameter.typeParameters, isNull);
-    expect(functionParameter.parameters, isNotNull);
-    expect(functionParameter.question, isNull);
-  }
-
-  void test_parseNormalFormalParameter_function_void() {
-    NormalFormalParameter parameter = parseNormalFormalParameter('void a()');
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isFunctionTypedFormalParameter);
-    FunctionTypedFormalParameter functionParameter = parameter;
-    expect(functionParameter.returnType, isNotNull);
-    expect(functionParameter.identifier, isNotNull);
-    expect(functionParameter.typeParameters, isNull);
-    expect(functionParameter.parameters, isNotNull);
-    expect(functionParameter.question, isNull);
-  }
-
-  void test_parseNormalFormalParameter_function_void_typeParameters() {
-    NormalFormalParameter parameter = parseNormalFormalParameter('void a<E>()');
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isFunctionTypedFormalParameter);
-    FunctionTypedFormalParameter functionParameter = parameter;
-    expect(functionParameter.returnType, isNotNull);
-    expect(functionParameter.identifier, isNotNull);
-    expect(functionParameter.typeParameters, isNotNull);
-    expect(functionParameter.parameters, isNotNull);
-    expect(functionParameter.question, isNull);
-  }
-
-  void test_parseNormalFormalParameter_function_withDocComment() {
-    var parameter = parseFormalParameter('/// Doc\nf()', ParameterKind.REQUIRED)
-        as FunctionTypedFormalParameter;
-    expectCommentText(parameter.documentationComment, '/// Doc');
-  }
-
-  void test_parseNormalFormalParameter_simple_const_noType() {
-    NormalFormalParameter parameter = parseNormalFormalParameter('const a',
-        errorCodes: [ParserErrorCode.EXTRANEOUS_MODIFIER]);
-    expect(parameter, isNotNull);
-    expect(parameter, isSimpleFormalParameter);
-    SimpleFormalParameter simpleParameter = parameter;
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-  }
-
-  void test_parseNormalFormalParameter_simple_const_type() {
-    NormalFormalParameter parameter = parseNormalFormalParameter('const A a',
-        errorCodes: [ParserErrorCode.EXTRANEOUS_MODIFIER]);
-    expect(parameter, isNotNull);
-    expect(parameter, isSimpleFormalParameter);
-    SimpleFormalParameter simpleParameter = parameter;
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.identifier, isNotNull);
-  }
-
-  void test_parseNormalFormalParameter_simple_final_noType() {
-    NormalFormalParameter parameter = parseNormalFormalParameter('final a');
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isSimpleFormalParameter);
-    SimpleFormalParameter simpleParameter = parameter;
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-  }
-
-  void test_parseNormalFormalParameter_simple_final_type() {
-    NormalFormalParameter parameter = parseNormalFormalParameter('final A a');
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isSimpleFormalParameter);
-    SimpleFormalParameter simpleParameter = parameter;
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.identifier, isNotNull);
-  }
-
-  void test_parseNormalFormalParameter_simple_noName() {
-    NormalFormalParameter parameter =
-        parseNormalFormalParameter('a', inFunctionType: true);
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isSimpleFormalParameter);
-    SimpleFormalParameter simpleParameter = parameter;
-    expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.identifier, isNull);
-  }
-
-  void test_parseNormalFormalParameter_simple_noType() {
-    NormalFormalParameter parameter = parseNormalFormalParameter('a');
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isSimpleFormalParameter);
-    SimpleFormalParameter simpleParameter = parameter;
-    expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-  }
-
-  void test_parseNormalFormalParameter_simple_noType_namedCovariant() {
-    NormalFormalParameter parameter = parseNormalFormalParameter('covariant');
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isSimpleFormalParameter);
-    SimpleFormalParameter simpleParameter = parameter;
-    expect(simpleParameter.covariantKeyword, isNull);
-    expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.identifier, isNotNull);
-  }
-
-  void test_parseNormalFormalParameter_simple_type() {
-    NormalFormalParameter parameter = parseNormalFormalParameter('A a');
-    expect(parameter, isNotNull);
-    assertNoErrors();
-    expect(parameter, isSimpleFormalParameter);
-    SimpleFormalParameter simpleParameter = parameter;
-    expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.identifier, isNotNull);
-  }
-}
-
-@reflectiveTest
-class NonErrorParserTest extends ParserTestCase {
-  void test_annotationOnEnumConstant_first() {
-    createParser("enum E { @override C }");
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    assertNoErrors();
-  }
-
-  void test_annotationOnEnumConstant_middle() {
-    createParser("enum E { C, @override D, E }");
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    assertNoErrors();
-  }
-
-  void test_staticMethod_notParsingFunctionBodies() {
-    ParserTestCase.parseFunctionBodies = false;
-    try {
-      createParser('class C { static void m() {} }');
-      CompilationUnit unit = parser.parseCompilationUnit2();
-      expectNotNullIfNoErrors(unit);
-      assertNoErrors();
-    } finally {
-      ParserTestCase.parseFunctionBodies = true;
-    }
-  }
-}
-
-/// The class `RecoveryParserTest` defines parser tests that test the parsing of
-/// invalid code sequences to ensure that the correct recovery steps are taken
-/// in the parser.
-mixin RecoveryParserTestMixin implements AbstractParserViaProxyTestCase {
-  void test_additiveExpression_missing_LHS() {
-    BinaryExpression expression =
-        parseExpression("+ y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.leftOperand, isSimpleIdentifier);
-    expect(expression.leftOperand.isSynthetic, isTrue);
-  }
-
-  void test_additiveExpression_missing_LHS_RHS() {
-    BinaryExpression expression = parseExpression("+", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isSimpleIdentifier);
-    expect(expression.leftOperand.isSynthetic, isTrue);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_additiveExpression_missing_RHS() {
-    BinaryExpression expression =
-        parseExpression("x +", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_additiveExpression_missing_RHS_super() {
-    BinaryExpression expression =
-        parseExpression("super +", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_additiveExpression_precedence_multiplicative_left() {
-    BinaryExpression expression = parseExpression("* +", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_additiveExpression_precedence_multiplicative_right() {
-    BinaryExpression expression = parseExpression("+ *", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.rightOperand, isBinaryExpression);
-  }
-
-  void test_additiveExpression_super() {
-    BinaryExpression expression = parseExpression("super + +", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_assignableSelector() {
-    IndexExpression expression =
-        parseExpression("a.b[]", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    Expression index = expression.index;
-    expect(index, isSimpleIdentifier);
-    expect(index.isSynthetic, isTrue);
-  }
-
-  void test_assignmentExpression_missing_compound1() {
-    AssignmentExpression expression =
-        parseExpression("= y = 0", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    Expression syntheticExpression = expression.leftHandSide;
-    expect(syntheticExpression, isSimpleIdentifier);
-    expect(syntheticExpression.isSynthetic, isTrue);
-  }
-
-  void test_assignmentExpression_missing_compound2() {
-    AssignmentExpression expression =
-        parseExpression("x = = 0", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    Expression syntheticExpression =
-        (expression.rightHandSide as AssignmentExpression).leftHandSide;
-    expect(syntheticExpression, isSimpleIdentifier);
-    expect(syntheticExpression.isSynthetic, isTrue);
-  }
-
-  void test_assignmentExpression_missing_compound3() {
-    AssignmentExpression expression =
-        parseExpression("x = y =", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    Expression syntheticExpression =
-        (expression.rightHandSide as AssignmentExpression).rightHandSide;
-    expect(syntheticExpression, isSimpleIdentifier);
-    expect(syntheticExpression.isSynthetic, isTrue);
-  }
-
-  void test_assignmentExpression_missing_LHS() {
-    AssignmentExpression expression =
-        parseExpression("= 0", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.leftHandSide, isSimpleIdentifier);
-    expect(expression.leftHandSide.isSynthetic, isTrue);
-  }
-
-  void test_assignmentExpression_missing_RHS() {
-    AssignmentExpression expression =
-        parseExpression("x =", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.leftHandSide, isSimpleIdentifier);
-    expect(expression.rightHandSide.isSynthetic, isTrue);
-  }
-
-  void test_bitwiseAndExpression_missing_LHS() {
-    BinaryExpression expression =
-        parseExpression("& y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.leftOperand, isSimpleIdentifier);
-    expect(expression.leftOperand.isSynthetic, isTrue);
-  }
-
-  void test_bitwiseAndExpression_missing_LHS_RHS() {
-    BinaryExpression expression = parseExpression("&", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isSimpleIdentifier);
-    expect(expression.leftOperand.isSynthetic, isTrue);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_bitwiseAndExpression_missing_RHS() {
-    BinaryExpression expression =
-        parseExpression("x &", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_bitwiseAndExpression_missing_RHS_super() {
-    BinaryExpression expression =
-        parseExpression("super &", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_bitwiseAndExpression_precedence_equality_left() {
-    BinaryExpression expression = parseExpression("== &&", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_bitwiseAndExpression_precedence_equality_right() {
-    BinaryExpression expression = parseExpression("&& ==", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.rightOperand, isBinaryExpression);
-  }
-
-  void test_bitwiseAndExpression_super() {
-    BinaryExpression expression = parseExpression("super &  &", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_bitwiseOrExpression_missing_LHS() {
-    BinaryExpression expression =
-        parseExpression("| y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.leftOperand, isSimpleIdentifier);
-    expect(expression.leftOperand.isSynthetic, isTrue);
-  }
-
-  void test_bitwiseOrExpression_missing_LHS_RHS() {
-    BinaryExpression expression = parseExpression("|", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isSimpleIdentifier);
-    expect(expression.leftOperand.isSynthetic, isTrue);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_bitwiseOrExpression_missing_RHS() {
-    BinaryExpression expression =
-        parseExpression("x |", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_bitwiseOrExpression_missing_RHS_super() {
-    BinaryExpression expression =
-        parseExpression("super |", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_bitwiseOrExpression_precedence_xor_left() {
-    BinaryExpression expression = parseExpression("^ |", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_bitwiseOrExpression_precedence_xor_right() {
-    BinaryExpression expression = parseExpression("| ^", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.rightOperand, isBinaryExpression);
-  }
-
-  void test_bitwiseOrExpression_super() {
-    BinaryExpression expression = parseExpression("super |  |", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_bitwiseXorExpression_missing_LHS() {
-    BinaryExpression expression =
-        parseExpression("^ y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.leftOperand, isSimpleIdentifier);
-    expect(expression.leftOperand.isSynthetic, isTrue);
-  }
-
-  void test_bitwiseXorExpression_missing_LHS_RHS() {
-    BinaryExpression expression = parseExpression("^", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isSimpleIdentifier);
-    expect(expression.leftOperand.isSynthetic, isTrue);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_bitwiseXorExpression_missing_RHS() {
-    BinaryExpression expression =
-        parseExpression("x ^", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_bitwiseXorExpression_missing_RHS_super() {
-    BinaryExpression expression =
-        parseExpression("super ^", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_bitwiseXorExpression_precedence_and_left() {
-    BinaryExpression expression = parseExpression("& ^", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_bitwiseXorExpression_precedence_and_right() {
-    BinaryExpression expression = parseExpression("^ &", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.rightOperand, isBinaryExpression);
-  }
-
-  void test_bitwiseXorExpression_super() {
-    BinaryExpression expression = parseExpression("super ^  ^", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_classTypeAlias_withBody() {
-    parseCompilationUnit(r'''
-class A {}
-class B = Object with A {}''', codes:
-            // TODO(danrubel): Consolidate and improve error message.
-            [
-      ParserErrorCode.EXPECTED_EXECUTABLE,
-      ParserErrorCode.EXPECTED_TOKEN
-    ]);
-  }
-
-  void test_combinator_badIdentifier() {
-    createParser('import "/testB.dart" show @');
-    parser.parseCompilationUnit2();
-    listener.assertErrors([
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 26, 1),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 27, 0),
-      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 27, 0),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 27, 0)
-    ]);
-  }
-
-  void test_combinator_missingIdentifier() {
-    createParser('import "/testB.dart" show ;');
-    parser.parseCompilationUnit2();
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 26, 1)]);
-  }
-
-  void test_conditionalExpression_missingElse() {
-    Expression expression =
-        parseExpression('x ? y :', codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expectNotNullIfNoErrors(expression);
-    expect(expression, isConditionalExpression);
-    ConditionalExpression conditionalExpression = expression;
-    expect(conditionalExpression.elseExpression, isSimpleIdentifier);
-    expect(conditionalExpression.elseExpression.isSynthetic, isTrue);
-  }
-
-  void test_conditionalExpression_missingThen() {
-    Expression expression =
-        parseExpression('x ? : z', codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expectNotNullIfNoErrors(expression);
-    expect(expression, isConditionalExpression);
-    ConditionalExpression conditionalExpression = expression;
-    expect(conditionalExpression.thenExpression, isSimpleIdentifier);
-    expect(conditionalExpression.thenExpression.isSynthetic, isTrue);
-  }
-
-  void test_conditionalExpression_super() {
-    parseExpression('x ? super : z', errors: [
-      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 4, 5)
-    ]);
-  }
-
-  void test_conditionalExpression_super2() {
-    parseExpression('x ? z : super', errors: [
-      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 8, 5)
-    ]);
-  }
-
-  void test_declarationBeforeDirective() {
-    CompilationUnit unit = parseCompilationUnit(
-        "class foo { } import 'bar.dart';",
-        codes: [ParserErrorCode.DIRECTIVE_AFTER_DECLARATION]);
-    expect(unit.directives, hasLength(1));
-    expect(unit.declarations, hasLength(1));
-    ClassDeclaration classDecl = unit.childEntities.first;
-    expect(classDecl, isNotNull);
-    expect(classDecl.name.name, 'foo');
-  }
-
-  void test_equalityExpression_missing_LHS() {
-    BinaryExpression expression =
-        parseExpression("== y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.leftOperand, isSimpleIdentifier);
-    expect(expression.leftOperand.isSynthetic, isTrue);
-  }
-
-  void test_equalityExpression_missing_LHS_RHS() {
-    BinaryExpression expression = parseExpression("==", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isSimpleIdentifier);
-    expect(expression.leftOperand.isSynthetic, isTrue);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_equalityExpression_missing_RHS() {
-    BinaryExpression expression =
-        parseExpression("x ==", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_equalityExpression_missing_RHS_super() {
-    BinaryExpression expression = parseExpression("super ==",
-        codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_equalityExpression_precedence_relational_right() {
-    BinaryExpression expression = parseExpression("== is", codes: [
-      ParserErrorCode.EXPECTED_TYPE_NAME,
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.rightOperand, isIsExpression);
-  }
-
-  void test_equalityExpression_super() {
-    BinaryExpression expression = parseExpression("super ==  ==", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND
-    ]);
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_equalityExpression_superRHS() {
-    parseExpression("1 == super", errors: [
-      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 5, 5)
-    ]);
-  }
-
-  void test_expressionList_multiple_end() {
-    List<Expression> result = parseExpressionList(', 2, 3, 4');
-    expectNotNullIfNoErrors(result);
-    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
-    listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
-//    listener.assertErrors(
-//        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 0, 1)]);
-    expect(result, hasLength(4));
-    Expression syntheticExpression = result[0];
-    expect(syntheticExpression, isSimpleIdentifier);
-    expect(syntheticExpression.isSynthetic, isTrue);
-  }
-
-  void test_expressionList_multiple_middle() {
-    List<Expression> result = parseExpressionList('1, 2, , 4');
-    expectNotNullIfNoErrors(result);
-    // TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
-    listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
-//    listener.assertErrors(
-//        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 1)]);
-    expect(result, hasLength(4));
-    Expression syntheticExpression = result[2];
-    expect(syntheticExpression, isSimpleIdentifier);
-    expect(syntheticExpression.isSynthetic, isTrue);
-  }
-
-  void test_expressionList_multiple_start() {
-    List<Expression> result = parseExpressionList('1, 2, 3,');
-    expectNotNullIfNoErrors(result);
-    // The fasta parser does not use parseExpressionList when parsing for loops
-    // and instead parseExpressionList is mapped to parseExpression('[$code]')
-    // which allows and ignores an optional trailing comma.
-    assertNoErrors();
-    expect(result, hasLength(3));
-  }
-
-  void test_functionExpression_in_ConstructorFieldInitializer() {
-    CompilationUnit unit =
-        parseCompilationUnit("class A { A() : a = (){}; var v; }", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.EXPECTED_CLASS_MEMBER
-    ]);
-    // Make sure we recovered and parsed "var v" correctly
-    ClassDeclaration declaration = unit.declarations[0] as ClassDeclaration;
-    NodeList<ClassMember> members = declaration.members;
-    ClassMember fieldDecl = members[1];
-    expect(fieldDecl, isFieldDeclaration);
-    NodeList<VariableDeclaration> vars =
-        (fieldDecl as FieldDeclaration).fields.variables;
-    expect(vars, hasLength(1));
-    expect(vars[0].name.name, "v");
-  }
-
-  void test_functionExpression_named() {
-    parseExpression("m(f() => 0);",
-        expectedEndOffset: 11,
-        codes: [ParserErrorCode.NAMED_FUNCTION_EXPRESSION]);
-  }
-
-  void test_ifStatement_noElse_statement() {
-    parseStatement('if (x v) f(x);');
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 6, 1)]);
-  }
-
-  void test_importDirectivePartial_as() {
-    CompilationUnit unit = parseCompilationUnit("import 'b.dart' d as b;",
-        codes: [ParserErrorCode.UNEXPECTED_TOKEN]);
-    ImportDirective importDirective = unit.childEntities.first;
-    expect(importDirective.asKeyword, isNotNull);
-    expect(unit.directives, hasLength(1));
-    expect(unit.declarations, hasLength(0));
-  }
-
-  void test_importDirectivePartial_hide() {
-    CompilationUnit unit = parseCompilationUnit("import 'b.dart' d hide foo;",
-        codes: [ParserErrorCode.UNEXPECTED_TOKEN]);
-    ImportDirective importDirective = unit.childEntities.first;
-    expect(importDirective.combinators, hasLength(1));
-    expect(unit.directives, hasLength(1));
-    expect(unit.declarations, hasLength(0));
-  }
-
-  void test_importDirectivePartial_show() {
-    CompilationUnit unit = parseCompilationUnit("import 'b.dart' d show foo;",
-        codes: [ParserErrorCode.UNEXPECTED_TOKEN]);
-    ImportDirective importDirective = unit.childEntities.first;
-    expect(importDirective.combinators, hasLength(1));
-    expect(unit.directives, hasLength(1));
-    expect(unit.declarations, hasLength(0));
-  }
-
-  void test_incomplete_conditionalExpression() {
-    parseExpression("x ? 0", codes: [
-      ParserErrorCode.EXPECTED_TOKEN,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-  }
-
-  void test_incomplete_constructorInitializers_empty() {
-    createParser('C() : {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.MISSING_INITIALIZER, 4, 1)]);
-  }
-
-  void test_incomplete_constructorInitializers_missingEquals() {
-    createParser('C() : x(3) {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 6, 1)
-    ]);
-    expect(member, isConstructorDeclaration);
-    NodeList<ConstructorInitializer> initializers =
-        (member as ConstructorDeclaration).initializers;
-    expect(initializers, hasLength(1));
-    ConstructorInitializer initializer = initializers[0];
-    expect(initializer, isConstructorFieldInitializer);
-    Expression expression =
-        (initializer as ConstructorFieldInitializer).expression;
-    expect(expression, isNotNull);
-    expect(expression, isMethodInvocation);
-  }
-
-  void test_incomplete_constructorInitializers_this() {
-    createParser('C() : this {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 11, 1),
-      expectedError(ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 6, 4)
-    ]);
-  }
-
-  void test_incomplete_constructorInitializers_thisField() {
-    createParser('C() : this.g {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 6, 4)
-    ]);
-  }
-
-  void test_incomplete_constructorInitializers_thisPeriod() {
-    createParser('C() : this. {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 12, 1),
-      expectedError(ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 6, 4)
-    ]);
-  }
-
-  void test_incomplete_constructorInitializers_variable() {
-    createParser('C() : x {}');
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 6, 1)
-    ]);
-  }
-
-  void test_incomplete_functionExpression() {
-    var expression = parseExpression("() a => null",
-        errors: [expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 3, 1)]);
-    FunctionExpression functionExpression = expression;
-    expect(functionExpression.parameters.parameters, hasLength(0));
-  }
-
-  void test_incomplete_functionExpression2() {
-    var expression = parseExpression("() a {}",
-        errors: [expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 3, 1)]);
-    FunctionExpression functionExpression = expression;
-    expect(functionExpression.parameters.parameters, hasLength(0));
-  }
-
-  void test_incomplete_returnType() {
-    parseCompilationUnit(r'''
-Map<Symbol, convertStringToSymbolMap(Map<String, dynamic> map) {
-  if (map == null) return null;
-  Map<Symbol, dynamic> result = new Map<Symbol, dynamic>();
-  map.forEach((name, value) {
-    result[new Symbol(name)] = value;
-  });
-  return result;
-}''', errors: [
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 12, 24),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 0, 3)
-    ]);
-  }
-
-  void test_incomplete_topLevelFunction() {
-    parseCompilationUnit("foo();",
-        codes: [ParserErrorCode.MISSING_FUNCTION_BODY]);
-  }
-
-  void test_incomplete_topLevelVariable() {
-    CompilationUnit unit = parseCompilationUnit("String", errors: [
-      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 0, 6),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 0, 6)
-    ]);
-    NodeList<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(1));
-    CompilationUnitMember member = declarations[0];
-    expect(member, isTopLevelVariableDeclaration);
-    NodeList<VariableDeclaration> variables =
-        (member as TopLevelVariableDeclaration).variables.variables;
-    expect(variables, hasLength(1));
-    SimpleIdentifier name = variables[0].name;
-    expect(name.isSynthetic, isFalse);
-  }
-
-  void test_incomplete_topLevelVariable_const() {
-    CompilationUnit unit = parseCompilationUnit("const ", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.EXPECTED_TOKEN
-    ]);
-    NodeList<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(1));
-    CompilationUnitMember member = declarations[0];
-    expect(member, isTopLevelVariableDeclaration);
-    NodeList<VariableDeclaration> variables =
-        (member as TopLevelVariableDeclaration).variables.variables;
-    expect(variables, hasLength(1));
-    SimpleIdentifier name = variables[0].name;
-    expect(name.isSynthetic, isTrue);
-  }
-
-  void test_incomplete_topLevelVariable_final() {
-    CompilationUnit unit = parseCompilationUnit("final ", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.EXPECTED_TOKEN
-    ]);
-    NodeList<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(1));
-    CompilationUnitMember member = declarations[0];
-    expect(member, isTopLevelVariableDeclaration);
-    NodeList<VariableDeclaration> variables =
-        (member as TopLevelVariableDeclaration).variables.variables;
-    expect(variables, hasLength(1));
-    SimpleIdentifier name = variables[0].name;
-    expect(name.isSynthetic, isTrue);
-  }
-
-  void test_incomplete_topLevelVariable_var() {
-    CompilationUnit unit = parseCompilationUnit("var ", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.EXPECTED_TOKEN
-    ]);
-    NodeList<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(1));
-    CompilationUnitMember member = declarations[0];
-    expect(member, isTopLevelVariableDeclaration);
-    NodeList<VariableDeclaration> variables =
-        (member as TopLevelVariableDeclaration).variables.variables;
-    expect(variables, hasLength(1));
-    SimpleIdentifier name = variables[0].name;
-    expect(name.isSynthetic, isTrue);
-  }
-
-  void test_incompleteField_const() {
-    CompilationUnit unit = parseCompilationUnit(r'''
-class C {
-  const
-}''', codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.EXPECTED_TOKEN
-    ]);
-    NodeList<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(1));
-    CompilationUnitMember unitMember = declarations[0];
-    expect(unitMember, isClassDeclaration);
-    NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
-    expect(members, hasLength(1));
-    ClassMember classMember = members[0];
-    expect(classMember, isFieldDeclaration);
-    VariableDeclarationList fieldList =
-        (classMember as FieldDeclaration).fields;
-    expect(fieldList.keyword.keyword, Keyword.CONST);
-    NodeList<VariableDeclaration> fields = fieldList.variables;
-    expect(fields, hasLength(1));
-    VariableDeclaration field = fields[0];
-    expect(field.name.isSynthetic, isTrue);
-  }
-
-  void test_incompleteField_final() {
-    CompilationUnit unit = parseCompilationUnit(r'''
-class C {
-  final
-}''', codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.EXPECTED_TOKEN
-    ]);
-    NodeList<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(1));
-    CompilationUnitMember unitMember = declarations[0];
-    expect(unitMember, isClassDeclaration);
-    NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
-    expect(members, hasLength(1));
-    ClassMember classMember = members[0];
-    expect(classMember, isFieldDeclaration);
-    VariableDeclarationList fieldList =
-        (classMember as FieldDeclaration).fields;
-    expect(fieldList.keyword.keyword, Keyword.FINAL);
-    NodeList<VariableDeclaration> fields = fieldList.variables;
-    expect(fields, hasLength(1));
-    VariableDeclaration field = fields[0];
-    expect(field.name.isSynthetic, isTrue);
-  }
-
-  void test_incompleteField_static() {
-    CompilationUnit unit = parseCompilationUnit(r'''
-class C {
-  static c
-}''', codes: [
-      ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE,
-      ParserErrorCode.EXPECTED_TOKEN
-    ]);
-    NodeList<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(1));
-    CompilationUnitMember unitMember = declarations[0];
-    expect(unitMember, isClassDeclaration);
-    NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
-    expect(members, hasLength(1));
-    ClassMember classMember = members[0];
-    expect(classMember, isFieldDeclaration);
-    FieldDeclaration declaration = classMember;
-    expect(declaration.staticKeyword.lexeme, 'static');
-    VariableDeclarationList fieldList = declaration.fields;
-    expect(fieldList.keyword, isNull);
-    NodeList<VariableDeclaration> fields = fieldList.variables;
-    expect(fields, hasLength(1));
-    VariableDeclaration field = fields[0];
-    expect(field.name.isSynthetic, isFalse);
-  }
-
-  void test_incompleteField_static2() {
-    CompilationUnit unit = parseCompilationUnit(r'''
-class C {
-  static c x
-}''', codes: [ParserErrorCode.EXPECTED_TOKEN]);
-    NodeList<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(1));
-    CompilationUnitMember unitMember = declarations[0];
-    expect(unitMember, isClassDeclaration);
-    NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
-    expect(members, hasLength(1));
-    ClassMember classMember = members[0];
-    expect(classMember, isFieldDeclaration);
-    FieldDeclaration declaration = classMember;
-    expect(declaration.staticKeyword.lexeme, 'static');
-    VariableDeclarationList fieldList = declaration.fields;
-    expect(fieldList.keyword, isNull);
-    NodeList<VariableDeclaration> fields = fieldList.variables;
-    expect(fields, hasLength(1));
-    VariableDeclaration field = fields[0];
-    expect(field.name.isSynthetic, isFalse);
-  }
-
-  void test_incompleteField_type() {
-    CompilationUnit unit = parseCompilationUnit(r'''
-class C {
-  A
-}''', codes: [
-      ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE,
-      ParserErrorCode.EXPECTED_TOKEN
-    ]);
-    NodeList<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(1));
-    CompilationUnitMember unitMember = declarations[0];
-    expect(unitMember, isClassDeclaration);
-    NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
-    expect(members, hasLength(1));
-    ClassMember classMember = members[0];
-    expect(classMember, isFieldDeclaration);
-    VariableDeclarationList fieldList =
-        (classMember as FieldDeclaration).fields;
-    TypeName type = fieldList.type;
-    NodeList<VariableDeclaration> fields = fieldList.variables;
-    expect(fields, hasLength(1));
-    VariableDeclaration field = fields[0];
-    expect(type, isNull);
-    expect(field.name.name, 'A');
-  }
-
-  void test_incompleteField_var() {
-    CompilationUnit unit = parseCompilationUnit(r'''
-class C {
-  var
-}''', codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.EXPECTED_TOKEN
-    ]);
-    NodeList<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(1));
-    CompilationUnitMember unitMember = declarations[0];
-    expect(unitMember, isClassDeclaration);
-    NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
-    expect(members, hasLength(1));
-    ClassMember classMember = members[0];
-    expect(classMember, isFieldDeclaration);
-    VariableDeclarationList fieldList =
-        (classMember as FieldDeclaration).fields;
-    expect(fieldList.keyword.keyword, Keyword.VAR);
-    NodeList<VariableDeclaration> fields = fieldList.variables;
-    expect(fields, hasLength(1));
-    VariableDeclaration field = fields[0];
-    expect(field.name.isSynthetic, isTrue);
-  }
-
-  void test_incompleteForEach() {
-    // TODO(danrubel): remove this once control flow and spread collection
-    // entry parsing is enabled by default
-    ForStatement statement = parseStatement('for (String item i) {}');
-    listener.assertErrors([
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 12, 4),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 17, 1)
-    ]);
-    expect(statement, isForStatement);
-    expect(statement.toSource(), 'for (String item; i;) {}');
-    var forParts = statement.forLoopParts as ForParts;
-    expect(forParts.leftSeparator, isNotNull);
-    expect(forParts.leftSeparator.type, TokenType.SEMICOLON);
-    expect(forParts.rightSeparator, isNotNull);
-    expect(forParts.rightSeparator.type, TokenType.SEMICOLON);
-  }
-
-  void test_incompleteLocalVariable_atTheEndOfBlock() {
-    Statement statement = parseStatement('String v }', expectedEndOffset: 9);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
-    expect(statement, isVariableDeclarationStatement);
-    expect(statement.toSource(), 'String v;');
-  }
-
-  void test_incompleteLocalVariable_atTheEndOfBlock_modifierOnly() {
-    Statement statement = parseStatement('final }', expectedEndOffset: 6);
-    listener.assertErrors([
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 1),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 6, 1)
-    ]);
-    expect(statement, isVariableDeclarationStatement);
-    expect(statement.toSource(), 'final ;');
-  }
-
-  void test_incompleteLocalVariable_beforeIdentifier() {
-    Statement statement =
-        parseStatement('String v String v2;', expectedEndOffset: 9);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
-    expect(statement, isVariableDeclarationStatement);
-    expect(statement.toSource(), 'String v;');
-  }
-
-  void test_incompleteLocalVariable_beforeKeyword() {
-    Statement statement =
-        parseStatement('String v if (true) {}', expectedEndOffset: 9);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
-    expect(statement, isVariableDeclarationStatement);
-    expect(statement.toSource(), 'String v;');
-  }
-
-  void test_incompleteLocalVariable_beforeNextBlock() {
-    Statement statement = parseStatement('String v {}', expectedEndOffset: 9);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
-    expect(statement, isVariableDeclarationStatement);
-    expect(statement.toSource(), 'String v;');
-  }
-
-  void test_incompleteLocalVariable_parameterizedType() {
-    Statement statement =
-        parseStatement('List<String> v {}', expectedEndOffset: 15);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 13, 1)]);
-    expect(statement, isVariableDeclarationStatement);
-    expect(statement.toSource(), 'List<String> v;');
-  }
-
-  void test_incompleteTypeArguments_field() {
-    CompilationUnit unit = parseCompilationUnit(r'''
-class C {
-  final List<int f;
-}''', errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 23, 3)]);
-    // one class
-    List<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(1));
-    ClassDeclaration classDecl = declarations[0] as ClassDeclaration;
-    // one field declaration
-    List<ClassMember> members = classDecl.members;
-    expect(members, hasLength(1));
-    FieldDeclaration fieldDecl = members[0] as FieldDeclaration;
-    // one field
-    VariableDeclarationList fieldList = fieldDecl.fields;
-    List<VariableDeclaration> fields = fieldList.variables;
-    expect(fields, hasLength(1));
-    VariableDeclaration field = fields[0];
-    expect(field.name.name, 'f');
-    // validate the type
-    TypeArgumentList typeArguments = (fieldList.type as TypeName).typeArguments;
-    expect(typeArguments.arguments, hasLength(1));
-    // synthetic '>'
-    Token token = typeArguments.endToken;
-    expect(token.type, TokenType.GT);
-    expect(token.isSynthetic, isTrue);
-  }
-
-  void test_incompleteTypeParameters() {
-    CompilationUnit unit = parseCompilationUnit(r'''
-class C<K {
-}''', errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 8, 1)]);
-    // one class
-    List<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(1));
-    ClassDeclaration classDecl = declarations[0] as ClassDeclaration;
-    // validate the type parameters
-    TypeParameterList typeParameters = classDecl.typeParameters;
-    expect(typeParameters.typeParameters, hasLength(1));
-    // synthetic '>'
-    Token token = typeParameters.endToken;
-    expect(token.type, TokenType.GT);
-    expect(token.isSynthetic, isTrue);
-  }
-
-  void test_incompleteTypeParameters2() {
-    CompilationUnit unit = parseCompilationUnit(r'''
-class C<K extends L<T> {
-}''', errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 21, 1)]);
-    // one class
-    List<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(1));
-    ClassDeclaration classDecl = declarations[0] as ClassDeclaration;
-    // validate the type parameters
-    TypeParameterList typeParameters = classDecl.typeParameters;
-    expect(typeParameters.typeParameters, hasLength(1));
-    // synthetic '>'
-    Token token = typeParameters.endToken;
-    expect(token.type, TokenType.GT);
-    expect(token.isSynthetic, isTrue);
-  }
-
-  void test_incompleteTypeParameters3() {
-    CompilationUnit unit = parseCompilationUnit(r'''
-class C<K extends L<T {
-}''', errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 20, 1)]);
-    // one class
-    List<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(1));
-    ClassDeclaration classDecl = declarations[0] as ClassDeclaration;
-    // validate the type parameters
-    TypeParameterList typeParameters = classDecl.typeParameters;
-    expect(typeParameters.typeParameters, hasLength(1));
-    // synthetic '>'
-    Token token = typeParameters.endToken;
-    expect(token.type, TokenType.GT);
-    expect(token.isSynthetic, isTrue);
-  }
-
-  void test_invalidFunctionBodyModifier() {
-    parseCompilationUnit("f() sync {}",
-        codes: [ParserErrorCode.MISSING_STAR_AFTER_SYNC]);
-  }
-
-  void test_invalidMapLiteral() {
-    parseCompilationUnit("class C { var f = Map<A, B> {}; }", codes: [
-      // TODO(danrubel): Improve error message to indicate
-      // that "Map" should be removed.
-      ParserErrorCode.EXPECTED_TOKEN,
-      ParserErrorCode.MISSING_KEYWORD_OPERATOR,
-      ParserErrorCode.MISSING_METHOD_PARAMETERS,
-      ParserErrorCode.EXPECTED_CLASS_MEMBER,
-    ]);
-  }
-
-  void test_invalidTypeParameters() {
-    CompilationUnit unit = parseCompilationUnit(r'''
-class C {
-  G<int double> g;
-}''', errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 18, 6)]);
-    // one class
-    List<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(1));
-    // validate members
-    ClassDeclaration classDecl = declarations[0] as ClassDeclaration;
-    expect(classDecl.members, hasLength(1));
-    FieldDeclaration fields = classDecl.members.first;
-    expect(fields.fields.variables, hasLength(1));
-    VariableDeclaration field = fields.fields.variables.first;
-    expect(field.name.name, 'g');
-  }
-
-  void test_isExpression_noType() {
-    CompilationUnit unit = parseCompilationUnit(
-        "class Bar<T extends Foo> {m(x){if (x is ) return;if (x is !)}}",
-        codes: [
-          ParserErrorCode.EXPECTED_TYPE_NAME,
-          ParserErrorCode.EXPECTED_TYPE_NAME,
-          ParserErrorCode.MISSING_IDENTIFIER,
-          ParserErrorCode.EXPECTED_TOKEN,
-        ]);
-    ClassDeclaration declaration = unit.declarations[0] as ClassDeclaration;
-    MethodDeclaration method = declaration.members[0] as MethodDeclaration;
-    BlockFunctionBody body = method.body as BlockFunctionBody;
-    IfStatement ifStatement = body.block.statements[1] as IfStatement;
-    IsExpression expression = ifStatement.condition as IsExpression;
-    expect(expression.expression, isNotNull);
-    expect(expression.isOperator, isNotNull);
-    expect(expression.notOperator, isNotNull);
-    TypeAnnotation type = expression.type;
-    expect(type, isNotNull);
-    expect(type is TypeName && type.name.isSynthetic, isTrue);
-    ExpressionStatement thenStatement = ifStatement.thenStatement;
-    expect(thenStatement.semicolon.isSynthetic, isTrue);
-    SimpleIdentifier simpleId = thenStatement.expression;
-    expect(simpleId.isSynthetic, isTrue);
-  }
-
-  void test_issue_34610_get() {
-    final unit =
-        parseCompilationUnit('class C { get C.named => null; }', errors: [
-      expectedError(ParserErrorCode.GETTER_CONSTRUCTOR, 10, 3),
-      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 14, 1),
-    ]);
-    ClassDeclaration declaration = unit.declarations[0];
-    ConstructorDeclaration method = declaration.members[0];
-    expect(method.name.name, 'named');
-    expect(method.parameters, isNotNull);
-  }
-
-  void test_issue_34610_initializers() {
-    final unit = parseCompilationUnit('class C { C.named : super(); }',
-        errors: [
-          expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 10, 1)
-        ]);
-    ClassDeclaration declaration = unit.declarations[0];
-    ConstructorDeclaration constructor = declaration.members[0];
-    expect(constructor.name.name, 'named');
-    expect(constructor.parameters, isNotNull);
-    expect(constructor.parameters.parameters, hasLength(0));
-  }
-
-  void test_issue_34610_missing_param() {
-    final unit = parseCompilationUnit('class C { C => null; }', errors: [
-      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 10, 1)
-    ]);
-    ClassDeclaration declaration = unit.declarations[0];
-    ConstructorDeclaration constructor = declaration.members[0];
-    expect(constructor.name, isNull);
-    expect(constructor.parameters, isNotNull);
-    expect(constructor.parameters.parameters, hasLength(0));
-  }
-
-  void test_issue_34610_named_missing_param() {
-    final unit = parseCompilationUnit('class C { C.named => null; }', errors: [
-      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 10, 1)
-    ]);
-    ClassDeclaration declaration = unit.declarations[0];
-    ConstructorDeclaration constructor = declaration.members[0];
-    expect(constructor.name.name, 'named');
-    expect(constructor.parameters, isNotNull);
-    expect(constructor.parameters.parameters, hasLength(0));
-  }
-
-  void test_issue_34610_set() {
-    final unit =
-        parseCompilationUnit('class C { set C.named => null; }', errors: [
-      expectedError(ParserErrorCode.SETTER_CONSTRUCTOR, 10, 3),
-      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 14, 1),
-    ]);
-    ClassDeclaration declaration = unit.declarations[0];
-    ConstructorDeclaration method = declaration.members[0];
-    expect(method.name.name, 'named');
-    expect(method.parameters, isNotNull);
-    expect(method.parameters.parameters, hasLength(0));
-  }
-
-  void test_keywordInPlaceOfIdentifier() {
-    // TODO(brianwilkerson) We could do better with this.
-    parseCompilationUnit("do() {}",
-        codes: [ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD]);
-  }
-
-  void test_logicalAndExpression_missing_LHS() {
-    BinaryExpression expression =
-        parseExpression("&& y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.leftOperand, isSimpleIdentifier);
-    expect(expression.leftOperand.isSynthetic, isTrue);
-  }
-
-  void test_logicalAndExpression_missing_LHS_RHS() {
-    BinaryExpression expression = parseExpression("&&", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isSimpleIdentifier);
-    expect(expression.leftOperand.isSynthetic, isTrue);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_logicalAndExpression_missing_RHS() {
-    BinaryExpression expression =
-        parseExpression("x &&", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_logicalAndExpression_precedence_bitwiseOr_left() {
-    BinaryExpression expression = parseExpression("| &&", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_logicalAndExpression_precedence_bitwiseOr_right() {
-    BinaryExpression expression = parseExpression("&& |", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.rightOperand, isBinaryExpression);
-  }
-
-  void test_logicalOrExpression_missing_LHS() {
-    BinaryExpression expression =
-        parseExpression("|| y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.leftOperand, isSimpleIdentifier);
-    expect(expression.leftOperand.isSynthetic, isTrue);
-  }
-
-  void test_logicalOrExpression_missing_LHS_RHS() {
-    BinaryExpression expression = parseExpression("||", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isSimpleIdentifier);
-    expect(expression.leftOperand.isSynthetic, isTrue);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_logicalOrExpression_missing_RHS() {
-    BinaryExpression expression =
-        parseExpression("x ||", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_logicalOrExpression_precedence_logicalAnd_left() {
-    BinaryExpression expression = parseExpression("&& ||", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_logicalOrExpression_precedence_logicalAnd_right() {
-    BinaryExpression expression = parseExpression("|| &&", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.rightOperand, isBinaryExpression);
-  }
-
-  void test_method_missingBody() {
-    parseCompilationUnit("class C { b() }",
-        errors: [expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 14, 1)]);
-  }
-
-  void test_missing_commaInArgumentList() {
-    MethodInvocation expression = parseExpression("f(x: 1 y: 2)",
-        errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
-    NodeList<Expression> arguments = expression.argumentList.arguments;
-    expect(arguments, hasLength(2));
-  }
-
-  void test_missingComma_beforeNamedArgument() {
-    createParser('(a b: c)');
-    ArgumentList argumentList = parser.parseArgumentList();
-    expectNotNullIfNoErrors(argumentList);
-    listener
-        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 3, 1)]);
-    expect(argumentList.arguments, hasLength(2));
-  }
-
-  void test_missingGet() {
-    CompilationUnit unit = parseCompilationUnit(r'''
-class C {
-  int length {}
-  void foo() {}
-}''', errors: [
-      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 16, 6)
-    ]);
-    expect(unit, isNotNull);
-    ClassDeclaration classDeclaration =
-        unit.declarations[0] as ClassDeclaration;
-    NodeList<ClassMember> members = classDeclaration.members;
-    expect(members, hasLength(2));
-    expect(members[0], isMethodDeclaration);
-    ClassMember member = members[1];
-    expect(member, isMethodDeclaration);
-    expect((member as MethodDeclaration).name.name, "foo");
-  }
-
-  void test_missingIdentifier_afterAnnotation() {
-    createParser('@override }', expectedEndOffset: 10);
-    ClassMember member = parser.parseClassMember('C');
-    expectNotNullIfNoErrors(member);
-    listener.assertErrors(
-        [expectedError(ParserErrorCode.EXPECTED_CLASS_MEMBER, 10, 1)]);
-    // TODO(danrubel): Consider generating a sub method so that the
-    // existing annotation can be associated with a class member.
-    expect(member, isNull);
-  }
-
-  void test_missingSemicolon_varialeDeclarationList() {
-    void verify(CompilationUnitMember member, String expectedTypeName,
-        String expectedName, String expectedSemicolon) {
-      expect(member, isTopLevelVariableDeclaration);
-      TopLevelVariableDeclaration declaration = member;
-      VariableDeclarationList variableList = declaration.variables;
-      expect(variableList, isNotNull);
-      NodeList<VariableDeclaration> variables = variableList.variables;
-      expect(variables, hasLength(1));
-      VariableDeclaration variable = variables[0];
-      expect(variableList.type.toString(), expectedTypeName);
-      expect(variable.name.name, expectedName);
-      if (expectedSemicolon.isEmpty) {
-        expect(declaration.semicolon.isSynthetic, isTrue);
-      } else {
-        expect(declaration.semicolon.lexeme, expectedSemicolon);
-      }
-    }
-
-    // Fasta considers the `n` an extraneous modifier
-    // and parses this as a single top level declaration.
-    // TODO(danrubel): A better recovery
-    // would be to insert a synthetic comma after the `n`.
-    CompilationUnit unit = parseCompilationUnit('String n x = "";', codes: [
-      ParserErrorCode.EXPECTED_TOKEN,
-      ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE
-    ]);
-    expect(unit, isNotNull);
-    NodeList<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(2));
-    verify(declarations[0], 'String', 'n', '');
-    verify(declarations[1], 'null', 'x', ';');
-  }
-
-  void test_multiplicativeExpression_missing_LHS() {
-    BinaryExpression expression =
-        parseExpression("* y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.leftOperand, isSimpleIdentifier);
-    expect(expression.leftOperand.isSynthetic, isTrue);
-  }
-
-  void test_multiplicativeExpression_missing_LHS_RHS() {
-    BinaryExpression expression = parseExpression("*", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isSimpleIdentifier);
-    expect(expression.leftOperand.isSynthetic, isTrue);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_multiplicativeExpression_missing_RHS() {
-    BinaryExpression expression =
-        parseExpression("x *", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_multiplicativeExpression_missing_RHS_super() {
-    BinaryExpression expression =
-        parseExpression("super *", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_multiplicativeExpression_precedence_unary_left() {
-    BinaryExpression expression =
-        parseExpression("-x *", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.leftOperand, isPrefixExpression);
-  }
-
-  void test_multiplicativeExpression_precedence_unary_right() {
-    BinaryExpression expression =
-        parseExpression("* -y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.rightOperand, isPrefixExpression);
-  }
-
-  void test_multiplicativeExpression_super() {
-    BinaryExpression expression = parseExpression("super ==  ==", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND
-    ]);
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_namedParameterOutsideGroup() {
-    CompilationUnit unit =
-        parseCompilationUnit('class A { b(c: 0, Foo d: 0, e){} }', errors: [
-      expectedError(ParserErrorCode.NAMED_PARAMETER_OUTSIDE_GROUP, 13, 1),
-      expectedError(ParserErrorCode.NAMED_PARAMETER_OUTSIDE_GROUP, 23, 1)
-    ]);
-    expect(unit.declarations, hasLength(1));
-    ClassDeclaration classA = unit.declarations[0];
-    expect(classA.members, hasLength(1));
-    MethodDeclaration method = classA.members[0];
-    NodeList<FormalParameter> parameters = method.parameters.parameters;
-    expect(parameters, hasLength(3));
-    expect(parameters[0].isNamed, isTrue);
-    expect(parameters[1].isNamed, isTrue);
-    expect(parameters[2].isRequired, isTrue);
-  }
-
-  void test_nonStringLiteralUri_import() {
-    parseCompilationUnit("import dart:io; class C {}", errors: [
-      expectedError(ParserErrorCode.EXPECTED_STRING_LITERAL, 7, 4),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 4),
-      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 7, 4),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 4),
-      expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 11, 1),
-      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 12, 2)
-    ]);
-  }
-
-  void test_prefixExpression_missing_operand_minus() {
-    PrefixExpression expression =
-        parseExpression("-", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.operand, isSimpleIdentifier);
-    expect(expression.operand.isSynthetic, isTrue);
-    expect(expression.operator.type, TokenType.MINUS);
-  }
-
-  void test_primaryExpression_argumentDefinitionTest() {
-    SimpleIdentifier expression = parsePrimaryExpression('?a',
-        expectedEndOffset: 0,
-        errors: [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 0, 1)]);
-    expectNotNullIfNoErrors(expression);
-    expect(expression.isSynthetic, isTrue);
-  }
-
-  void test_propertyAccess_missing_LHS_RHS() {
-    Expression result = parseExpression(".", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    PrefixedIdentifier expression = result;
-    expect(expression.prefix.isSynthetic, isTrue);
-    expect(expression.period.lexeme, '.');
-    expect(expression.identifier.isSynthetic, isTrue);
-  }
-
-  void test_relationalExpression_missing_LHS() {
-    IsExpression expression =
-        parseExpression("is y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.expression, isSimpleIdentifier);
-    expect(expression.expression.isSynthetic, isTrue);
-  }
-
-  void test_relationalExpression_missing_LHS_RHS() {
-    IsExpression expression = parseExpression("is", codes: [
-      ParserErrorCode.EXPECTED_TYPE_NAME,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.expression, isSimpleIdentifier);
-    expect(expression.expression.isSynthetic, isTrue);
-    expect(expression.type, isTypeName);
-    expect(expression.type.isSynthetic, isTrue);
-  }
-
-  void test_relationalExpression_missing_RHS() {
-    IsExpression expression =
-        parseExpression("x is", codes: [ParserErrorCode.EXPECTED_TYPE_NAME]);
-    expect(expression.type, isTypeName);
-    expect(expression.type.isSynthetic, isTrue);
-  }
-
-  void test_relationalExpression_precedence_shift_right() {
-    IsExpression expression = parseExpression("<< is", codes: [
-      ParserErrorCode.EXPECTED_TYPE_NAME,
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.expression, isBinaryExpression);
-  }
-
-  void test_shiftExpression_missing_LHS() {
-    BinaryExpression expression =
-        parseExpression("<< y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.leftOperand, isSimpleIdentifier);
-    expect(expression.leftOperand.isSynthetic, isTrue);
-  }
-
-  void test_shiftExpression_missing_LHS_RHS() {
-    BinaryExpression expression = parseExpression("<<", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isSimpleIdentifier);
-    expect(expression.leftOperand.isSynthetic, isTrue);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_shiftExpression_missing_RHS() {
-    BinaryExpression expression =
-        parseExpression("x <<", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_shiftExpression_missing_RHS_super() {
-    BinaryExpression expression = parseExpression("super <<",
-        codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-    expect(expression.rightOperand, isSimpleIdentifier);
-    expect(expression.rightOperand.isSynthetic, isTrue);
-  }
-
-  void test_shiftExpression_precedence_unary_left() {
-    BinaryExpression expression = parseExpression("+ <<", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_shiftExpression_precedence_unary_right() {
-    BinaryExpression expression = parseExpression("<< +", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.rightOperand, isBinaryExpression);
-  }
-
-  void test_shiftExpression_super() {
-    BinaryExpression expression = parseExpression("super << <<", codes: [
-      ParserErrorCode.MISSING_IDENTIFIER,
-      ParserErrorCode.MISSING_IDENTIFIER
-    ]);
-    expect(expression.leftOperand, isBinaryExpression);
-  }
-
-  void test_typedef_eof() {
-    CompilationUnit unit = parseCompilationUnit("typedef n", codes: [
-      ParserErrorCode.EXPECTED_TOKEN,
-      ParserErrorCode.MISSING_TYPEDEF_PARAMETERS
-    ]);
-    NodeList<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(1));
-    CompilationUnitMember member = declarations[0];
-    expect(member, isFunctionTypeAlias);
-  }
-
-  void test_unaryPlus() {
-    parseExpression("+2", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
-  }
-}
-
-/// Parser tests that test individual parsing methods. The code fragments should
-/// be as minimal as possible in order to test the method, but should not test
-/// the interactions between the method under test and other methods.
-///
-/// More complex tests should be defined in the class [ComplexParserTest].
-mixin SimpleParserTestMixin implements AbstractParserViaProxyTestCase {
-  ConstructorName parseConstructorName(String name) {
-    createParser('new $name();');
-    Statement statement = parser.parseStatement2();
-    expect(statement, isExpressionStatement);
-    Expression expression = (statement as ExpressionStatement).expression;
-    expect(expression, isInstanceCreationExpression);
-    return (expression as InstanceCreationExpression).constructorName;
-  }
-
-  ExtendsClause parseExtendsClause(String clause) {
-    createParser('class TestClass $clause {}');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expect(unit, isNotNull);
-    expect(unit.declarations, hasLength(1));
-    ClassDeclaration classDecl = unit.declarations[0];
-    expect(classDecl, isNotNull);
-    return classDecl.extendsClause;
-  }
-
-  List<SimpleIdentifier> parseIdentifierList(String identifiers) {
-    createParser('show $identifiers');
-    List<Combinator> combinators = parser.parseCombinators();
-    expect(combinators, hasLength(1));
-    return (combinators[0] as ShowCombinator).shownNames;
-  }
-
-  ImplementsClause parseImplementsClause(String clause) {
-    createParser('class TestClass $clause {}');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expect(unit, isNotNull);
-    expect(unit.declarations, hasLength(1));
-    ClassDeclaration classDecl = unit.declarations[0];
-    expect(classDecl, isNotNull);
-    return classDecl.implementsClause;
-  }
-
-  LibraryIdentifier parseLibraryIdentifier(String name) {
-    createParser('library $name;');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expect(unit, isNotNull);
-    expect(unit.directives, hasLength(1));
-    LibraryDirective directive = unit.directives[0];
-    return directive.name;
-  }
-
-  /// Parse the given [content] as a sequence of statements by enclosing it in a
-  /// block. The [expectedCount] is the number of statements that are expected
-  /// to be parsed. If [errorCodes] are provided, verify that the error codes of
-  /// the errors that are expected are found.
-  void parseStatementList(String content, int expectedCount) {
-    Statement statement = parseStatement('{$content}');
-    expect(statement, isBlock);
-    Block block = statement;
-    expect(block.statements, hasLength(expectedCount));
-  }
-
-  VariableDeclaration parseVariableDeclaration(String declaration) {
-    createParser(declaration);
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expect(unit, isNotNull);
-    expect(unit.declarations, hasLength(1));
-    TopLevelVariableDeclaration decl = unit.declarations[0];
-    expect(decl, isNotNull);
-    return decl.variables.variables[0];
-  }
-
-  WithClause parseWithClause(String clause) {
-    createParser('class TestClass extends Object $clause {}');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expect(unit, isNotNull);
-    expect(unit.declarations, hasLength(1));
-    ClassDeclaration classDecl = unit.declarations[0];
-    expect(classDecl, isNotNull);
-    return classDecl.withClause;
-  }
-
-  void test_classDeclaration_complexTypeParam() {
-    CompilationUnit unit = parseCompilationUnit('''
-class C<@Foo.bar(const [], const [1], const{"":r""}, 0xFF + 2, .3, 4.5) T> {}
-''');
-    ClassDeclaration clazz = unit.declarations[0];
-    expect(clazz.name.name, 'C');
-    expect(clazz.typeParameters.typeParameters, hasLength(1));
-    TypeParameter typeParameter = clazz.typeParameters.typeParameters[0];
-    expect(typeParameter.name.name, 'T');
-    expect(typeParameter.metadata, hasLength(1));
-    Annotation metadata = typeParameter.metadata[0];
-    expect(metadata.name.name, 'Foo.bar');
-  }
-
-  void test_parseAnnotation_n1() {
-    createParser('@A');
-    Annotation annotation = parser.parseAnnotation();
-    expectNotNullIfNoErrors(annotation);
-    assertNoErrors();
-    expect(annotation.atSign, isNotNull);
-    expect(annotation.name, isNotNull);
-    expect(annotation.period, isNull);
-    expect(annotation.constructorName, isNull);
-    expect(annotation.arguments, isNull);
-  }
-
-  void test_parseAnnotation_n1_a() {
-    createParser('@A(x,y)');
-    Annotation annotation = parser.parseAnnotation();
-    expectNotNullIfNoErrors(annotation);
-    assertNoErrors();
-    expect(annotation.atSign, isNotNull);
-    expect(annotation.name, isNotNull);
-    expect(annotation.period, isNull);
-    expect(annotation.constructorName, isNull);
-    expect(annotation.arguments, isNotNull);
-  }
-
-  void test_parseAnnotation_n2() {
-    createParser('@A.B');
-    Annotation annotation = parser.parseAnnotation();
-    expectNotNullIfNoErrors(annotation);
-    assertNoErrors();
-    expect(annotation.atSign, isNotNull);
-    expect(annotation.name, isNotNull);
-    expect(annotation.period, isNull);
-    expect(annotation.constructorName, isNull);
-    expect(annotation.arguments, isNull);
-  }
-
-  void test_parseAnnotation_n2_a() {
-    createParser('@A.B(x,y)');
-    Annotation annotation = parser.parseAnnotation();
-    expectNotNullIfNoErrors(annotation);
-    assertNoErrors();
-    expect(annotation.atSign, isNotNull);
-    expect(annotation.name, isNotNull);
-    expect(annotation.period, isNull);
-    expect(annotation.constructorName, isNull);
-    expect(annotation.arguments, isNotNull);
-  }
-
-  void test_parseAnnotation_n3() {
-    createParser('@A.B.C');
-    Annotation annotation = parser.parseAnnotation();
-    expectNotNullIfNoErrors(annotation);
-    assertNoErrors();
-    expect(annotation.atSign, isNotNull);
-    expect(annotation.name, isNotNull);
-    expect(annotation.period, isNotNull);
-    expect(annotation.constructorName, isNotNull);
-    expect(annotation.arguments, isNull);
-  }
-
-  void test_parseAnnotation_n3_a() {
-    createParser('@A.B.C(x,y)');
-    Annotation annotation = parser.parseAnnotation();
-    expectNotNullIfNoErrors(annotation);
-    assertNoErrors();
-    expect(annotation.atSign, isNotNull);
-    expect(annotation.name, isNotNull);
-    expect(annotation.period, isNotNull);
-    expect(annotation.constructorName, isNotNull);
-    expect(annotation.arguments, isNotNull);
-  }
-
-  void test_parseArgumentList_empty() {
-    createParser('()');
-    ArgumentList argumentList = parser.parseArgumentList();
-    expectNotNullIfNoErrors(argumentList);
-    assertNoErrors();
-    NodeList<Expression> arguments = argumentList.arguments;
-    expect(arguments, hasLength(0));
-  }
-
-  void test_parseArgumentList_mixed() {
-    createParser('(w, x, y: y, z: z)');
-    ArgumentList argumentList = parser.parseArgumentList();
-    expectNotNullIfNoErrors(argumentList);
-    assertNoErrors();
-    NodeList<Expression> arguments = argumentList.arguments;
-    expect(arguments, hasLength(4));
-  }
-
-  void test_parseArgumentList_noNamed() {
-    createParser('(x, y, z)');
-    ArgumentList argumentList = parser.parseArgumentList();
-    expectNotNullIfNoErrors(argumentList);
-    assertNoErrors();
-    NodeList<Expression> arguments = argumentList.arguments;
-    expect(arguments, hasLength(3));
-  }
-
-  void test_parseArgumentList_onlyNamed() {
-    createParser('(x: x, y: y)');
-    ArgumentList argumentList = parser.parseArgumentList();
-    expectNotNullIfNoErrors(argumentList);
-    assertNoErrors();
-    NodeList<Expression> arguments = argumentList.arguments;
-    expect(arguments, hasLength(2));
-  }
-
-  void test_parseArgumentList_trailing_comma() {
-    createParser('(x, y, z,)');
-    ArgumentList argumentList = parser.parseArgumentList();
-    expectNotNullIfNoErrors(argumentList);
-    assertNoErrors();
-    NodeList<Expression> arguments = argumentList.arguments;
-    expect(arguments, hasLength(3));
-  }
-
-  void test_parseArgumentList_typeArguments() {
-    createParser('(a<b,c>(d))');
-    ArgumentList argumentList = parser.parseArgumentList();
-    expectNotNullIfNoErrors(argumentList);
-    assertNoErrors();
-    NodeList<Expression> arguments = argumentList.arguments;
-    expect(arguments, hasLength(1));
-  }
-
-  void test_parseArgumentList_typeArguments_none() {
-    createParser('(a<b,p.q.c>(d))');
-    ArgumentList argumentList = parser.parseArgumentList();
-    expectNotNullIfNoErrors(argumentList);
-    assertNoErrors();
-    NodeList<Expression> arguments = argumentList.arguments;
-    expect(arguments, hasLength(2));
-  }
-
-  void test_parseArgumentList_typeArguments_prefixed() {
-    createParser('(a<b,p.c>(d))');
-    ArgumentList argumentList = parser.parseArgumentList();
-    expectNotNullIfNoErrors(argumentList);
-    assertNoErrors();
-    NodeList<Expression> arguments = argumentList.arguments;
-    expect(arguments, hasLength(1));
-  }
-
-  void test_parseCombinators_h() {
-    createParser('hide a');
-    List<Combinator> combinators = parser.parseCombinators();
-    expectNotNullIfNoErrors(combinators);
-    assertNoErrors();
-    expect(combinators, hasLength(1));
-    HideCombinator combinator = combinators[0] as HideCombinator;
-    expect(combinator, isNotNull);
-    expect(combinator.keyword, isNotNull);
-    expect(combinator.hiddenNames, hasLength(1));
-  }
-
-  void test_parseCombinators_hs() {
-    createParser('hide a show b');
-    List<Combinator> combinators = parser.parseCombinators();
-    expectNotNullIfNoErrors(combinators);
-    assertNoErrors();
-    expect(combinators, hasLength(2));
-    HideCombinator hideCombinator = combinators[0] as HideCombinator;
-    expect(hideCombinator, isNotNull);
-    expect(hideCombinator.keyword, isNotNull);
-    expect(hideCombinator.hiddenNames, hasLength(1));
-    ShowCombinator showCombinator = combinators[1] as ShowCombinator;
-    expect(showCombinator, isNotNull);
-    expect(showCombinator.keyword, isNotNull);
-    expect(showCombinator.shownNames, hasLength(1));
-  }
-
-  void test_parseCombinators_hshs() {
-    createParser('hide a show b hide c show d');
-    List<Combinator> combinators = parser.parseCombinators();
-    expectNotNullIfNoErrors(combinators);
-    assertNoErrors();
-    expect(combinators, hasLength(4));
-  }
-
-  void test_parseCombinators_s() {
-    createParser('show a');
-    List<Combinator> combinators = parser.parseCombinators();
-    expectNotNullIfNoErrors(combinators);
-    assertNoErrors();
-    expect(combinators, hasLength(1));
-    ShowCombinator combinator = combinators[0] as ShowCombinator;
-    expect(combinator, isNotNull);
-    expect(combinator.keyword, isNotNull);
-    expect(combinator.shownNames, hasLength(1));
-  }
-
-  void test_parseCommentAndMetadata_c() {
-    createParser('/** 1 */ class C {}');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    assertNoErrors();
-    ClassDeclaration declaration = unit.declarations[0];
-    expect(declaration.documentationComment, isNotNull);
-    expect(declaration.metadata, isEmpty);
-  }
-
-  void test_parseCommentAndMetadata_cmc() {
-    createParser('/** 1 */ @A /** 2 */ class C {}');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    assertNoErrors();
-    ClassDeclaration declaration = unit.declarations[0];
-    Comment comment = declaration.documentationComment;
-    expect(comment.isDocumentation, isTrue);
-    expect(comment.tokens, hasLength(1));
-    expect(comment.tokens[0].lexeme, '/** 2 */');
-    expect(declaration.metadata, hasLength(1));
-  }
-
-  void test_parseCommentAndMetadata_cmcm() {
-    createParser('/** 1 */ @A /** 2 */ @B class C {}');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    assertNoErrors();
-    ClassDeclaration declaration = unit.declarations[0];
-    expect(declaration.documentationComment, isNotNull);
-    expect(declaration.metadata, hasLength(2));
-  }
-
-  void test_parseCommentAndMetadata_cmm() {
-    createParser('/** 1 */ @A @B class C {}');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    assertNoErrors();
-    ClassDeclaration declaration = unit.declarations[0];
-    expect(declaration.documentationComment, isNotNull);
-    expect(declaration.metadata, hasLength(2));
-  }
-
-  void test_parseCommentAndMetadata_m() {
-    createParser('@A class C {}');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    assertNoErrors();
-    ClassDeclaration declaration = unit.declarations[0];
-    expect(declaration.documentationComment, isNull);
-    expect(declaration.metadata, hasLength(1));
-  }
-
-  void test_parseCommentAndMetadata_mcm() {
-    createParser('@A /** 1 */ @B class C {}');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    assertNoErrors();
-    ClassDeclaration declaration = unit.declarations[0];
-    expect(declaration.documentationComment, isNotNull);
-    expect(declaration.metadata, hasLength(2));
-  }
-
-  void test_parseCommentAndMetadata_mcmc() {
-    createParser('@A /** 1 */ @B /** 2 */ class C {}');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    assertNoErrors();
-    ClassDeclaration declaration = unit.declarations[0];
-    expect(declaration.documentationComment, isNotNull);
-    expect(declaration.documentationComment.tokens[0].lexeme, contains('2'));
-    expect(declaration.metadata, hasLength(2));
-  }
-
-  void test_parseCommentAndMetadata_mix1() {
-    createParser(r'''
-/**
- * aaa
- */
-/**
- * bbb
- */
-class A {}
-''');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    assertNoErrors();
-    ClassDeclaration declaration = unit.declarations[0];
-    expect(declaration.metadata, hasLength(0));
-    List<Token> tokens = declaration.documentationComment.tokens;
-    expect(tokens, hasLength(1));
-    expect(tokens[0].lexeme, contains('bbb'));
-  }
-
-  void test_parseCommentAndMetadata_mix2() {
-    createParser(r'''
-/**
- * aaa
- */
-/// bbb
-/// ccc
-class B {}
-''');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    assertNoErrors();
-    ClassDeclaration declaration = unit.declarations[0];
-    expect(declaration.metadata, hasLength(0));
-    List<Token> tokens = declaration.documentationComment.tokens;
-    expect(tokens, hasLength(2));
-    expect(tokens[0].lexeme, contains('bbb'));
-    expect(tokens[1].lexeme, contains('ccc'));
-  }
-
-  void test_parseCommentAndMetadata_mix3() {
-    createParser(r'''
-/// aaa
-/// bbb
-/**
- * ccc
- */
-class C {}
-''');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    assertNoErrors();
-    ClassDeclaration declaration = unit.declarations[0];
-    expect(declaration.metadata, hasLength(0));
-    List<Token> tokens = declaration.documentationComment.tokens;
-    expect(tokens, hasLength(1));
-    expect(tokens[0].lexeme, contains('ccc'));
-  }
-
-  test_parseCommentAndMetadata_mix4() {
-    createParser(r'''
-/// aaa
-/// bbb
-/**
- * ccc
- */
-/// ddd
-class D {}
-''');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    assertNoErrors();
-    ClassDeclaration declaration = unit.declarations[0];
-    expect(declaration.metadata, hasLength(0));
-    List<Token> tokens = declaration.documentationComment.tokens;
-    expect(tokens, hasLength(1));
-    expect(tokens[0].lexeme, contains('ddd'));
-  }
-
-  test_parseCommentAndMetadata_mix5() {
-    createParser(r'''
-/**
- * aaa
- */
-// bbb
-class E {}
-''');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    assertNoErrors();
-    ClassDeclaration declaration = unit.declarations[0];
-    expect(declaration.metadata, hasLength(0));
-    List<Token> tokens = declaration.documentationComment.tokens;
-    expect(tokens, hasLength(1));
-    expect(tokens[0].lexeme, contains('aaa'));
-  }
-
-  void test_parseCommentAndMetadata_mm() {
-    createParser('@A @B(x) class C {}');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    assertNoErrors();
-    ClassDeclaration declaration = unit.declarations[0];
-    expect(declaration.documentationComment, isNull);
-    expect(declaration.metadata, hasLength(2));
-  }
-
-  void test_parseCommentAndMetadata_none() {
-    createParser('class C {}');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    assertNoErrors();
-    ClassDeclaration declaration = unit.declarations[0];
-    expect(declaration.documentationComment, isNull);
-    expect(declaration.metadata, isEmpty);
-  }
-
-  void test_parseCommentAndMetadata_singleLine() {
-    createParser(r'''
-/// 1
-/// 2
-class C {}
-''');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expectNotNullIfNoErrors(unit);
-    assertNoErrors();
-    ClassDeclaration declaration = unit.declarations[0];
-    expect(declaration.documentationComment, isNotNull);
-    expect(declaration.metadata, isEmpty);
-  }
-
-  void test_parseCommentReference_new_prefixed() {
-    createParser('');
-    CommentReference reference = parseCommentReference('new a.b', 7);
-    expectNotNullIfNoErrors(reference);
-    assertNoErrors();
-    expect(reference.identifier, isPrefixedIdentifier);
-    PrefixedIdentifier prefixedIdentifier = reference.identifier;
-    SimpleIdentifier prefix = prefixedIdentifier.prefix;
-    expect(prefix.token, isNotNull);
-    expect(prefix.name, "a");
-    expect(prefix.offset, 11);
-    expect(prefixedIdentifier.period, isNotNull);
-    SimpleIdentifier identifier = prefixedIdentifier.identifier;
-    expect(identifier.token, isNotNull);
-    expect(identifier.name, "b");
-    expect(identifier.offset, 13);
-  }
-
-  void test_parseCommentReference_new_simple() {
-    createParser('');
-    CommentReference reference = parseCommentReference('new a', 5);
-    expectNotNullIfNoErrors(reference);
-    assertNoErrors();
-    expect(reference.identifier, isSimpleIdentifier);
-    SimpleIdentifier identifier = reference.identifier;
-    expect(identifier.token, isNotNull);
-    expect(identifier.name, "a");
-    expect(identifier.offset, 9);
-  }
-
-  void test_parseCommentReference_operator_withKeyword_notPrefixed() {
-    createParser('');
-    CommentReference reference = parseCommentReference('operator ==', 5);
-    expectNotNullIfNoErrors(reference);
-    assertNoErrors();
-    expect(reference.identifier, isSimpleIdentifier);
-    SimpleIdentifier identifier = reference.identifier;
-    expect(identifier.token, isNotNull);
-    expect(identifier.name, "==");
-    expect(identifier.offset, 14);
-  }
-
-  void test_parseCommentReference_operator_withKeyword_prefixed() {
-    createParser('');
-    CommentReference reference = parseCommentReference('Object.operator==', 7);
-    expectNotNullIfNoErrors(reference);
-    assertNoErrors();
-    expect(reference.identifier, isPrefixedIdentifier);
-    PrefixedIdentifier prefixedIdentifier = reference.identifier;
-    SimpleIdentifier prefix = prefixedIdentifier.prefix;
-    expect(prefix.token, isNotNull);
-    expect(prefix.name, "Object");
-    expect(prefix.offset, 7);
-    expect(prefixedIdentifier.period, isNotNull);
-    SimpleIdentifier identifier = prefixedIdentifier.identifier;
-    expect(identifier.token, isNotNull);
-    expect(identifier.name, "==");
-    expect(identifier.offset, 22);
-  }
-
-  void test_parseCommentReference_operator_withoutKeyword_notPrefixed() {
-    createParser('');
-    CommentReference reference = parseCommentReference('==', 5);
-    expectNotNullIfNoErrors(reference);
-    assertNoErrors();
-    expect(reference.identifier, isSimpleIdentifier);
-    SimpleIdentifier identifier = reference.identifier;
-    expect(identifier.token, isNotNull);
-    expect(identifier.name, "==");
-    expect(identifier.offset, 5);
-  }
-
-  void test_parseCommentReference_operator_withoutKeyword_prefixed() {
-    createParser('');
-    CommentReference reference = parseCommentReference('Object.==', 7);
-    expectNotNullIfNoErrors(reference);
-    assertNoErrors();
-    expect(reference.identifier, isPrefixedIdentifier);
-    PrefixedIdentifier prefixedIdentifier = reference.identifier;
-    SimpleIdentifier prefix = prefixedIdentifier.prefix;
-    expect(prefix.token, isNotNull);
-    expect(prefix.name, "Object");
-    expect(prefix.offset, 7);
-    expect(prefixedIdentifier.period, isNotNull);
-    SimpleIdentifier identifier = prefixedIdentifier.identifier;
-    expect(identifier.token, isNotNull);
-    expect(identifier.name, "==");
-    expect(identifier.offset, 14);
-  }
-
-  void test_parseCommentReference_prefixed() {
-    createParser('');
-    CommentReference reference = parseCommentReference('a.b', 7);
-    expectNotNullIfNoErrors(reference);
-    assertNoErrors();
-    expect(reference.identifier, isPrefixedIdentifier);
-    PrefixedIdentifier prefixedIdentifier = reference.identifier;
-    SimpleIdentifier prefix = prefixedIdentifier.prefix;
-    expect(prefix.token, isNotNull);
-    expect(prefix.name, "a");
-    expect(prefix.offset, 7);
-    expect(prefixedIdentifier.period, isNotNull);
-    SimpleIdentifier identifier = prefixedIdentifier.identifier;
-    expect(identifier.token, isNotNull);
-    expect(identifier.name, "b");
-    expect(identifier.offset, 9);
-  }
-
-  void test_parseCommentReference_simple() {
-    createParser('');
-    CommentReference reference = parseCommentReference('a', 5);
-    expectNotNullIfNoErrors(reference);
-    assertNoErrors();
-    expect(reference.identifier, isSimpleIdentifier);
-    SimpleIdentifier identifier = reference.identifier;
-    expect(identifier.token, isNotNull);
-    expect(identifier.name, "a");
-    expect(identifier.offset, 5);
-  }
-
-  void test_parseCommentReference_synthetic() {
-    createParser('');
-    CommentReference reference = parseCommentReference('', 5);
-    expectNotNullIfNoErrors(reference);
-    assertNoErrors();
-    expect(reference.identifier, isSimpleIdentifier);
-    SimpleIdentifier identifier = reference.identifier;
-    expect(identifier, isNotNull);
-    expect(identifier.isSynthetic, isTrue);
-    expect(identifier.token, isNotNull);
-    expect(identifier.name, "");
-    expect(identifier.offset, 5);
-    // Should end with EOF token.
-    Token nextToken = identifier.token.next;
-    expect(nextToken, isNotNull);
-    expect(nextToken.type, TokenType.EOF);
-  }
-
-  @failingTest
-  void test_parseCommentReference_this() {
-    // This fails because we are returning null from the method and asserting
-    // that the return value is not null.
-    createParser('');
-    CommentReference reference = parseCommentReference('this', 5);
-    expectNotNullIfNoErrors(reference);
-    assertNoErrors();
-    SimpleIdentifier identifier = reference.identifier;
-    expect(identifier.token, isNotNull);
-    expect(identifier.name, "a");
-    expect(identifier.offset, 5);
-  }
-
-  void test_parseCommentReferences_33738() {
-    CompilationUnit unit =
-        parseCompilationUnit('/** [String] */ abstract class Foo {}');
-    ClassDeclaration clazz = unit.declarations[0];
-    Comment comment = clazz.documentationComment;
-    expect(clazz.isAbstract, isTrue);
-    List<CommentReference> references = comment.references;
-    expect(references, hasLength(1));
-    CommentReference reference = references[0];
-    expect(reference, isNotNull);
-    expect(reference.identifier, isNotNull);
-    expect(reference.offset, 5);
-  }
-
-  void test_parseCommentReferences_beforeAnnotation() {
-    CompilationUnit unit = parseCompilationUnit('''
-/// See [int] and [String]
-/// and [Object].
-@Annotation
-abstract class Foo {}
-''');
-    ClassDeclaration clazz = unit.declarations[0];
-    Comment comment = clazz.documentationComment;
-    expect(clazz.isAbstract, isTrue);
-    List<CommentReference> references = comment.references;
-    expect(references, hasLength(3));
-
-    expectReference(int index, String expectedText, int expectedOffset) {
-      CommentReference reference = references[index];
-      expect(reference.identifier.name, expectedText);
-      expect(reference.offset, expectedOffset);
-    }
-
-    expectReference(0, 'int', 9);
-    expectReference(1, 'String', 19);
-    expectReference(2, 'Object', 36);
-  }
-
-  void test_parseCommentReferences_complex() {
-    CompilationUnit unit = parseCompilationUnit('''
-/// This dartdoc comment [should] be ignored
-@Annotation
-/// This dartdoc comment is [included].
-// a non dartdoc comment [inbetween]
-/// See [int] and [String] but `not [a]`
-/// ```
-/// This [code] block should be ignored
-/// ```
-/// and [Object].
-abstract class Foo {}
-''');
-    ClassDeclaration clazz = unit.declarations[0];
-    Comment comment = clazz.documentationComment;
-    expect(clazz.isAbstract, isTrue);
-    List<CommentReference> references = comment.references;
-    expect(references, hasLength(4));
-
-    expectReference(int index, String expectedText, int expectedOffset) {
-      CommentReference reference = references[index];
-      expect(reference.identifier.name, expectedText);
-      expect(reference.offset, expectedOffset);
-    }
-
-    expectReference(0, 'included', 86);
-    expectReference(1, 'int', 143);
-    expectReference(2, 'String', 153);
-    expectReference(3, 'Object', 240);
-  }
-
-  void test_parseCommentReferences_multiLine() {
-    DocumentationCommentToken token = DocumentationCommentToken(
-        TokenType.MULTI_LINE_COMMENT, "/** xxx [a] yyy [bb] zzz */", 3);
-    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[token];
-    createParser('');
-    List<CommentReference> references = parser.parseCommentReferences(tokens);
-    expectNotNullIfNoErrors(references);
-    assertNoErrors();
-    expect(references, hasLength(2));
-    {
-      CommentReference reference = references[0];
-      expect(reference, isNotNull);
-      expect(reference.identifier, isNotNull);
-      expect(reference.offset, 12);
-      Token referenceToken = reference.identifier.beginToken;
-      expect(referenceToken.offset, 12);
-      expect(referenceToken.lexeme, 'a');
-    }
-    {
-      CommentReference reference = references[1];
-      expect(reference, isNotNull);
-      expect(reference.identifier, isNotNull);
-      expect(reference.offset, 20);
-      Token referenceToken = reference.identifier.beginToken;
-      expect(referenceToken.offset, 20);
-      expect(referenceToken.lexeme, 'bb');
-    }
-  }
-
-  void test_parseCommentReferences_notClosed_noIdentifier() {
-    DocumentationCommentToken docToken = DocumentationCommentToken(
-        TokenType.MULTI_LINE_COMMENT, "/** [ some text", 5);
-    createParser('');
-    List<CommentReference> references =
-        parser.parseCommentReferences(<DocumentationCommentToken>[docToken]);
-    expectNotNullIfNoErrors(references);
-    assertNoErrors();
-    expect(references, hasLength(1));
-    CommentReference reference = references[0];
-    Token referenceToken = reference.identifier.beginToken;
-    expect(reference, isNotNull);
-    expect(reference.identifier, isNotNull);
-    expect(reference.identifier.isSynthetic, isTrue);
-    expect(reference.identifier.name, "");
-    // Should end with EOF token.
-    Token nextToken = referenceToken.next;
-    expect(nextToken, isNotNull);
-    expect(nextToken.type, TokenType.EOF);
-  }
-
-  void test_parseCommentReferences_notClosed_withIdentifier() {
-    DocumentationCommentToken docToken = DocumentationCommentToken(
-        TokenType.MULTI_LINE_COMMENT, "/** [namePrefix some text", 5);
-    createParser('');
-    List<CommentReference> references =
-        parser.parseCommentReferences(<DocumentationCommentToken>[docToken]);
-    expectNotNullIfNoErrors(references);
-    assertNoErrors();
-    expect(references, hasLength(1));
-    CommentReference reference = references[0];
-    Token referenceToken = reference.identifier.beginToken;
-    expect(reference, isNotNull);
-    expect(referenceToken, same(reference.beginToken));
-    expect(reference.identifier, isNotNull);
-    expect(reference.identifier.isSynthetic, isFalse);
-    expect(reference.identifier.name, "namePrefix");
-    // Should end with EOF token.
-    Token nextToken = referenceToken.next;
-    expect(nextToken, isNotNull);
-    expect(nextToken.type, TokenType.EOF);
-  }
-
-  void test_parseCommentReferences_singleLine() {
-    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
-      DocumentationCommentToken(
-          TokenType.SINGLE_LINE_COMMENT, "/// xxx [a] yyy [b] zzz", 3),
-      DocumentationCommentToken(TokenType.SINGLE_LINE_COMMENT, "/// x [c]", 28)
-    ];
-    createParser('');
-    List<CommentReference> references = parser.parseCommentReferences(tokens);
-    expectNotNullIfNoErrors(references);
-    assertNoErrors();
-    expect(references, hasLength(3));
-    CommentReference reference = references[0];
-    expect(reference, isNotNull);
-    expect(reference.identifier, isNotNull);
-    expect(reference.offset, 12);
-    reference = references[1];
-    expect(reference, isNotNull);
-    expect(reference.identifier, isNotNull);
-    expect(reference.offset, 20);
-    reference = references[2];
-    expect(reference, isNotNull);
-    expect(reference.identifier, isNotNull);
-    expect(reference.offset, 35);
-  }
-
-  void test_parseCommentReferences_skipCodeBlock_4spaces_block() {
-    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
-      DocumentationCommentToken(TokenType.MULTI_LINE_COMMENT,
-          "/**\n *     a[i]\n * non-code line\n */", 3)
-    ];
-    createParser('');
-    List<CommentReference> references = parser.parseCommentReferences(tokens);
-    expectNotNullIfNoErrors(references);
-    assertNoErrors();
-    expect(references, isEmpty);
-  }
-
-  void test_parseCommentReferences_skipCodeBlock_4spaces_lines() {
-    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
-      DocumentationCommentToken(
-          TokenType.SINGLE_LINE_COMMENT, "/// Code block:", 0),
-      DocumentationCommentToken(
-          TokenType.SINGLE_LINE_COMMENT, "///     a[i] == b[i]", 0)
-    ];
-    createParser('');
-    List<CommentReference> references = parser.parseCommentReferences(tokens);
-    expectNotNullIfNoErrors(references);
-    assertNoErrors();
-    expect(references, isEmpty);
-  }
-
-  void test_parseCommentReferences_skipCodeBlock_bracketed() {
-    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
-      DocumentationCommentToken(
-          TokenType.MULTI_LINE_COMMENT, "/** [:xxx [a] yyy:] [b] zzz */", 3)
-    ];
-    createParser('');
-    List<CommentReference> references = parser.parseCommentReferences(tokens);
-    expectNotNullIfNoErrors(references);
-    assertNoErrors();
-    expect(references, hasLength(1));
-    CommentReference reference = references[0];
-    expect(reference, isNotNull);
-    expect(reference.identifier, isNotNull);
-    expect(reference.offset, 24);
-  }
-
-  void test_parseCommentReferences_skipCodeBlock_gitHub() {
-    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
-      DocumentationCommentToken(
-          TokenType.MULTI_LINE_COMMENT, "/** `a[i]` and [b] */", 0)
-    ];
-    createParser('');
-    List<CommentReference> references = parser.parseCommentReferences(tokens);
-    expectNotNullIfNoErrors(references);
-    assertNoErrors();
-    expect(references, hasLength(1));
-    CommentReference reference = references[0];
-    expect(reference, isNotNull);
-    expect(reference.identifier, isNotNull);
-    expect(reference.offset, 16);
-  }
-
-  void test_parseCommentReferences_skipCodeBlock_gitHub_multiLine() {
-    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
-      DocumentationCommentToken(
-          TokenType.MULTI_LINE_COMMENT,
-          r'''
-/**
- * First.
- * ```dart
- * Some [int] reference.
- * ```
- * Last.
- */
-''',
-          3)
-    ];
-    createParser('');
-    List<CommentReference> references = parser.parseCommentReferences(tokens);
-    expectNotNullIfNoErrors(references);
-    assertNoErrors();
-    expect(references, isEmpty);
-  }
-
-  void test_parseCommentReferences_skipCodeBlock_gitHub_multiLine_lines() {
-    String commentText = r'''
-/// First.
-/// ```dart
-/// Some [int] reference.
-/// ```
-/// Last.
-''';
-    List<DocumentationCommentToken> tokens = commentText
-        .split('\n')
-        .map((line) =>
-            DocumentationCommentToken(TokenType.SINGLE_LINE_COMMENT, line, 0))
-        .toList();
-    createParser('');
-    List<CommentReference> references = parser.parseCommentReferences(tokens);
-    expectNotNullIfNoErrors(references);
-    assertNoErrors();
-    expect(references, isEmpty);
-  }
-
-  void test_parseCommentReferences_skipCodeBlock_gitHub_notTerminated() {
-    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
-      DocumentationCommentToken(
-          TokenType.MULTI_LINE_COMMENT, "/** `a[i] and [b] */", 0)
-    ];
-    createParser('');
-    List<CommentReference> references = parser.parseCommentReferences(tokens);
-    expectNotNullIfNoErrors(references);
-    assertNoErrors();
-    expect(references, hasLength(2));
-  }
-
-  void test_parseCommentReferences_skipCodeBlock_spaces() {
-    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
-      DocumentationCommentToken(TokenType.MULTI_LINE_COMMENT,
-          "/**\n *     a[i]\n * xxx [i] zzz\n */", 3)
-    ];
-    createParser('');
-    List<CommentReference> references = parser.parseCommentReferences(tokens);
-    expectNotNullIfNoErrors(references);
-    assertNoErrors();
-    expect(references, hasLength(1));
-    CommentReference reference = references[0];
-    expect(reference, isNotNull);
-    expect(reference.identifier, isNotNull);
-    expect(reference.offset, 27);
-  }
-
-  void test_parseCommentReferences_skipLink_direct_multiLine() {
-    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
-      DocumentationCommentToken(
-          TokenType.MULTI_LINE_COMMENT,
-          '''
-/**
- * [a link split across multiple
- * lines](http://www.google.com) [b] zzz
- */
-''',
-          3)
-    ];
-    createParser('');
-    List<CommentReference> references = parser.parseCommentReferences(tokens);
-    expectNotNullIfNoErrors(references);
-    assertNoErrors();
-    expect(references, hasLength(1));
-    CommentReference reference = references[0];
-    expect(reference, isNotNull);
-    expect(reference.identifier, isNotNull);
-    expect(reference.offset, 74);
-  }
-
-  void test_parseCommentReferences_skipLink_direct_singleLine() {
-    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
-      DocumentationCommentToken(TokenType.MULTI_LINE_COMMENT,
-          "/** [a](http://www.google.com) [b] zzz */", 3)
-    ];
-    createParser('');
-    List<CommentReference> references = parser.parseCommentReferences(tokens);
-    expectNotNullIfNoErrors(references);
-    assertNoErrors();
-    expect(references, hasLength(1));
-    CommentReference reference = references[0];
-    expect(reference, isNotNull);
-    expect(reference.identifier, isNotNull);
-    expect(reference.offset, 35);
-  }
-
-  void test_parseCommentReferences_skipLink_reference_multiLine() {
-    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
-      DocumentationCommentToken(
-          TokenType.MULTI_LINE_COMMENT,
-          '''
-/**
- * [a link split across multiple
- * lines][c] [b] zzz
- */
-''',
-          3)
-    ];
-    createParser('');
-    List<CommentReference> references = parser.parseCommentReferences(tokens);
-    expectNotNullIfNoErrors(references);
-    assertNoErrors();
-    expect(references, hasLength(1));
-    CommentReference reference = references[0];
-    expect(reference, isNotNull);
-    expect(reference.identifier, isNotNull);
-    expect(reference.offset, 54);
-  }
-
-  void test_parseCommentReferences_skipLink_reference_singleLine() {
-    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
-      DocumentationCommentToken(
-          TokenType.MULTI_LINE_COMMENT, "/** [a][c] [b] zzz */", 3)
-    ];
-    createParser('');
-    List<CommentReference> references = parser.parseCommentReferences(tokens);
-    expectNotNullIfNoErrors(references);
-    assertNoErrors();
-    expect(references, hasLength(1));
-    CommentReference reference = references[0];
-    expect(reference, isNotNull);
-    expect(reference.identifier, isNotNull);
-    expect(reference.offset, 15);
-  }
-
-  void test_parseCommentReferences_skipLinkDefinition() {
-    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
-      DocumentationCommentToken(TokenType.MULTI_LINE_COMMENT,
-          "/** [a]: http://www.google.com (Google) [b] zzz */", 3)
-    ];
-    createParser('');
-    List<CommentReference> references = parser.parseCommentReferences(tokens);
-    expectNotNullIfNoErrors(references);
-    assertNoErrors();
-    expect(references, hasLength(1));
-    CommentReference reference = references[0];
-    expect(reference, isNotNull);
-    expect(reference.identifier, isNotNull);
-    expect(reference.offset, 44);
-  }
-
-  void test_parseConfiguration_noOperator_dottedIdentifier() {
-    createParser("if (a.b) 'c.dart'");
-    Configuration configuration = parser.parseConfiguration();
-    expectNotNullIfNoErrors(configuration);
-    assertNoErrors();
-    expect(configuration.ifKeyword, isNotNull);
-    expect(configuration.leftParenthesis, isNotNull);
-    expectDottedName(configuration.name, ["a", "b"]);
-    expect(configuration.equalToken, isNull);
-    expect(configuration.value, isNull);
-    expect(configuration.rightParenthesis, isNotNull);
-    expect(configuration.uri, isNotNull);
-  }
-
-  void test_parseConfiguration_noOperator_simpleIdentifier() {
-    createParser("if (a) 'b.dart'");
-    Configuration configuration = parser.parseConfiguration();
-    expectNotNullIfNoErrors(configuration);
-    assertNoErrors();
-    expect(configuration.ifKeyword, isNotNull);
-    expect(configuration.leftParenthesis, isNotNull);
-    expectDottedName(configuration.name, ["a"]);
-    expect(configuration.equalToken, isNull);
-    expect(configuration.value, isNull);
-    expect(configuration.rightParenthesis, isNotNull);
-    expect(configuration.uri, isNotNull);
-  }
-
-  void test_parseConfiguration_operator_dottedIdentifier() {
-    createParser("if (a.b == 'c') 'd.dart'");
-    Configuration configuration = parser.parseConfiguration();
-    expectNotNullIfNoErrors(configuration);
-    assertNoErrors();
-    expect(configuration.ifKeyword, isNotNull);
-    expect(configuration.leftParenthesis, isNotNull);
-    expectDottedName(configuration.name, ["a", "b"]);
-    expect(configuration.equalToken, isNotNull);
-    expect(configuration.value, isNotNull);
-    expect(configuration.rightParenthesis, isNotNull);
-    expect(configuration.uri, isNotNull);
-  }
-
-  void test_parseConfiguration_operator_simpleIdentifier() {
-    createParser("if (a == 'b') 'c.dart'");
-    Configuration configuration = parser.parseConfiguration();
-    expectNotNullIfNoErrors(configuration);
-    assertNoErrors();
-    expect(configuration.ifKeyword, isNotNull);
-    expect(configuration.leftParenthesis, isNotNull);
-    expectDottedName(configuration.name, ["a"]);
-    expect(configuration.equalToken, isNotNull);
-    expect(configuration.value, isNotNull);
-    expect(configuration.rightParenthesis, isNotNull);
-    expect(configuration.uri, isNotNull);
-  }
-
-  void test_parseConstructorName_named_noPrefix() {
-    ConstructorName name = parseConstructorName('A.n');
-    expectNotNullIfNoErrors(name);
-    assertNoErrors();
-    expect(name.type, isNotNull);
-    expect(name.period, isNull);
-    expect(name.name, isNull);
-  }
-
-  void test_parseConstructorName_named_prefixed() {
-    ConstructorName name = parseConstructorName('p.A.n');
-    expectNotNullIfNoErrors(name);
-    assertNoErrors();
-    expect(name.type, isNotNull);
-    expect(name.period, isNotNull);
-    expect(name.name, isNotNull);
-  }
-
-  void test_parseConstructorName_unnamed_noPrefix() {
-    ConstructorName name = parseConstructorName('A');
-    expectNotNullIfNoErrors(name);
-    assertNoErrors();
-    expect(name.type, isNotNull);
-    expect(name.period, isNull);
-    expect(name.name, isNull);
-  }
-
-  void test_parseConstructorName_unnamed_prefixed() {
-    ConstructorName name = parseConstructorName('p.A');
-    expectNotNullIfNoErrors(name);
-    assertNoErrors();
-    expect(name.type, isNotNull);
-    expect(name.period, isNull);
-    expect(name.name, isNull);
-  }
-
-  void test_parseDocumentationComment_block() {
-    createParser('/** */ class C {}');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    Comment comment = unit.declarations[0].documentationComment;
-    expectNotNullIfNoErrors(comment);
-    assertNoErrors();
-    expect(comment.isBlock, isFalse);
-    expect(comment.isDocumentation, isTrue);
-    expect(comment.isEndOfLine, isFalse);
-  }
-
-  void test_parseDocumentationComment_block_withReference() {
-    createParser('/** [a] */ class C {}');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    Comment comment = unit.declarations[0].documentationComment;
-    expectNotNullIfNoErrors(comment);
-    assertNoErrors();
-    expect(comment.isBlock, isFalse);
-    expect(comment.isDocumentation, isTrue);
-    expect(comment.isEndOfLine, isFalse);
-    NodeList<CommentReference> references = comment.references;
-    expect(references, hasLength(1));
-    CommentReference reference = references[0];
-    expect(reference, isNotNull);
-    expect(reference.offset, 5);
-  }
-
-  void test_parseDocumentationComment_endOfLine() {
-    createParser('/// \n/// \n class C {}');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    Comment comment = unit.declarations[0].documentationComment;
-    expectNotNullIfNoErrors(comment);
-    assertNoErrors();
-    expect(comment.isBlock, isFalse);
-    expect(comment.isDocumentation, isTrue);
-    expect(comment.isEndOfLine, isFalse);
-  }
-
-  void test_parseExtendsClause() {
-    ExtendsClause clause = parseExtendsClause('extends B');
-    expectNotNullIfNoErrors(clause);
-    assertNoErrors();
-    expect(clause.extendsKeyword, isNotNull);
-    expect(clause.superclass, isNotNull);
-    expect(clause.superclass, isTypeName);
-  }
-
-  void test_parseFunctionBody_block() {
-    createParser('{}');
-    FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
-    expectNotNullIfNoErrors(functionBody);
-    assertNoErrors();
-    expect(functionBody, isBlockFunctionBody);
-    BlockFunctionBody body = functionBody;
-    expect(body.keyword, isNull);
-    expect(body.star, isNull);
-    expect(body.block, isNotNull);
-    expect(body.isAsynchronous, isFalse);
-    expect(body.isGenerator, isFalse);
-    expect(body.isSynchronous, isTrue);
-  }
-
-  void test_parseFunctionBody_block_async() {
-    createParser('async {}');
-    FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
-    expectNotNullIfNoErrors(functionBody);
-    assertNoErrors();
-    expect(functionBody, isBlockFunctionBody);
-    BlockFunctionBody body = functionBody;
-    expect(body.keyword, isNotNull);
-    expect(body.keyword.lexeme, Keyword.ASYNC.lexeme);
-    expect(body.star, isNull);
-    expect(body.block, isNotNull);
-    expect(body.isAsynchronous, isTrue);
-    expect(body.isGenerator, isFalse);
-    expect(body.isSynchronous, isFalse);
-  }
-
-  void test_parseFunctionBody_block_asyncGenerator() {
-    createParser('async* {}');
-    FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
-    expectNotNullIfNoErrors(functionBody);
-    assertNoErrors();
-    expect(functionBody, isBlockFunctionBody);
-    BlockFunctionBody body = functionBody;
-    expect(body.keyword, isNotNull);
-    expect(body.keyword.lexeme, Keyword.ASYNC.lexeme);
-    expect(body.star, isNotNull);
-    expect(body.block, isNotNull);
-    expect(body.isAsynchronous, isTrue);
-    expect(body.isGenerator, isTrue);
-    expect(body.isSynchronous, isFalse);
-  }
-
-  void test_parseFunctionBody_block_syncGenerator() {
-    createParser('sync* {}');
-    FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
-    expectNotNullIfNoErrors(functionBody);
-    assertNoErrors();
-    expect(functionBody, isBlockFunctionBody);
-    BlockFunctionBody body = functionBody;
-    expect(body.keyword, isNotNull);
-    expect(body.keyword.lexeme, Keyword.SYNC.lexeme);
-    expect(body.star, isNotNull);
-    expect(body.block, isNotNull);
-    expect(body.isAsynchronous, isFalse);
-    expect(body.isGenerator, isTrue);
-    expect(body.isSynchronous, isTrue);
-  }
-
-  void test_parseFunctionBody_empty() {
-    createParser(';');
-    FunctionBody functionBody = parser.parseFunctionBody(true, null, false);
-    expectNotNullIfNoErrors(functionBody);
-    assertNoErrors();
-    expect(functionBody, isEmptyFunctionBody);
-    EmptyFunctionBody body = functionBody;
-    expect(body.semicolon, isNotNull);
-  }
-
-  void test_parseFunctionBody_expression() {
-    createParser('=> y;');
-    FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
-    expectNotNullIfNoErrors(functionBody);
-    assertNoErrors();
-    expect(functionBody, isExpressionFunctionBody);
-    ExpressionFunctionBody body = functionBody;
-    expect(body.keyword, isNull);
-    expect(body.functionDefinition, isNotNull);
-    expect(body.expression, isNotNull);
-    expect(body.semicolon, isNotNull);
-    expect(body.isAsynchronous, isFalse);
-    expect(body.isGenerator, isFalse);
-    expect(body.isSynchronous, isTrue);
-  }
-
-  void test_parseFunctionBody_expression_async() {
-    createParser('async => y;');
-    FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
-    expectNotNullIfNoErrors(functionBody);
-    assertNoErrors();
-    expect(functionBody, isExpressionFunctionBody);
-    ExpressionFunctionBody body = functionBody;
-    expect(body.keyword, isNotNull);
-    expect(body.keyword.lexeme, Keyword.ASYNC.lexeme);
-    expect(body.functionDefinition, isNotNull);
-    expect(body.expression, isNotNull);
-    expect(body.semicolon, isNotNull);
-    expect(body.isAsynchronous, isTrue);
-    expect(body.isGenerator, isFalse);
-    expect(body.isSynchronous, isFalse);
-  }
-
-  void test_parseIdentifierList_multiple() {
-    List<SimpleIdentifier> list = parseIdentifierList('a, b, c');
-    expectNotNullIfNoErrors(list);
-    assertNoErrors();
-    expect(list, hasLength(3));
-  }
-
-  void test_parseIdentifierList_single() {
-    List<SimpleIdentifier> list = parseIdentifierList('a');
-    expectNotNullIfNoErrors(list);
-    assertNoErrors();
-    expect(list, hasLength(1));
-  }
-
-  void test_parseImplementsClause_multiple() {
-    ImplementsClause clause = parseImplementsClause('implements A, B, C');
-    expectNotNullIfNoErrors(clause);
-    assertNoErrors();
-    expect(clause.interfaces, hasLength(3));
-    expect(clause.implementsKeyword, isNotNull);
-  }
-
-  void test_parseImplementsClause_single() {
-    ImplementsClause clause = parseImplementsClause('implements A');
-    expectNotNullIfNoErrors(clause);
-    assertNoErrors();
-    expect(clause.interfaces, hasLength(1));
-    expect(clause.implementsKeyword, isNotNull);
-  }
-
-  void test_parseInstanceCreation_keyword_33647() {
-    enableOptionalNewAndConst = true;
-    CompilationUnit unit = parseCompilationUnit('''
-var c = new Future<int>.sync(() => 3).then<int>((e) => e);
-''');
-    expect(unit, isNotNull);
-    TopLevelVariableDeclaration v = unit.declarations[0];
-    MethodInvocation init = v.variables.variables[0].initializer;
-    expect(init.methodName.name, 'then');
-    NodeList<TypeAnnotation> typeArg = init.typeArguments.arguments;
-    expect(typeArg, hasLength(1));
-    expect(typeArg[0].beginToken.lexeme, 'int');
-  }
-
-  void test_parseInstanceCreation_noKeyword_33647() {
-    enableOptionalNewAndConst = true;
-    CompilationUnit unit = parseCompilationUnit('''
-var c = Future<int>.sync(() => 3).then<int>((e) => e);
-''');
-    expect(unit, isNotNull);
-    TopLevelVariableDeclaration v = unit.declarations[0];
-    MethodInvocation init = v.variables.variables[0].initializer;
-    expect(init.methodName.name, 'then');
-    NodeList<TypeAnnotation> typeArg = init.typeArguments.arguments;
-    expect(typeArg, hasLength(1));
-    expect(typeArg[0].beginToken.lexeme, 'int');
-  }
-
-  void test_parseInstanceCreation_noKeyword_noPrefix() {
-    enableOptionalNewAndConst = true;
-    createParser('f() => C<E>.n();');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expect(unit, isNotNull);
-    FunctionDeclaration f = unit.declarations[0];
-    ExpressionFunctionBody body = f.functionExpression.body;
-    expect(body.expression, isInstanceCreationExpression);
-    InstanceCreationExpressionImpl creation = body.expression;
-    expect(creation.keyword, isNull);
-    ConstructorName constructorName = creation.constructorName;
-    expect(constructorName.type.toSource(), 'C<E>');
-    expect(constructorName.period, isNotNull);
-    expect(constructorName.name, isNotNull);
-    expect(creation.argumentList, isNotNull);
-    expect(creation.typeArguments, isNull);
-  }
-
-  void test_parseInstanceCreation_noKeyword_noPrefix_34403() {
-    enableOptionalNewAndConst = true;
-    createParser('f() => C<E>.n<B>();');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expect(unit, isNotNull);
-    FunctionDeclaration f = unit.declarations[0];
-    ExpressionFunctionBody body = f.functionExpression.body;
-    expect(body.expression, isInstanceCreationExpression);
-    InstanceCreationExpressionImpl creation = body.expression;
-    expect(creation.keyword, isNull);
-    ConstructorName constructorName = creation.constructorName;
-    expect(constructorName.type.toSource(), 'C<E>');
-    expect(constructorName.period, isNotNull);
-    expect(constructorName.name, isNotNull);
-    expect(creation.argumentList, isNotNull);
-    expect(creation.typeArguments.arguments, hasLength(1));
-  }
-
-  void test_parseInstanceCreation_noKeyword_prefix() {
-    enableOptionalNewAndConst = true;
-    createParser('f() => p.C<E>.n();');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expect(unit, isNotNull);
-    FunctionDeclaration f = unit.declarations[0];
-    ExpressionFunctionBody body = f.functionExpression.body;
-    expect(body.expression, isInstanceCreationExpression);
-    InstanceCreationExpression creation = body.expression;
-    expect(creation.keyword, isNull);
-    ConstructorName constructorName = creation.constructorName;
-    expect(constructorName.type.toSource(), 'p.C<E>');
-    expect(constructorName.period, isNotNull);
-    expect(constructorName.name, isNotNull);
-    expect(creation.argumentList, isNotNull);
-  }
-
-  void test_parseInstanceCreation_noKeyword_varInit() {
-    enableOptionalNewAndConst = true;
-    createParser('''
-class C<T, S> {}
-void main() {final c = C<int, int Function(String)>();}
-''');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expect(unit, isNotNull);
-    FunctionDeclaration f = unit.declarations[1];
-    BlockFunctionBody body = f.functionExpression.body;
-    VariableDeclarationStatement statement = body.block.statements[0];
-    VariableDeclaration variable = statement.variables.variables[0];
-    MethodInvocation creation = variable.initializer;
-    expect(creation.methodName.name, 'C');
-    expect(creation.typeArguments.toSource(), '<int, int Function(String)>');
-  }
-
-  void test_parseLibraryIdentifier_builtin() {
-    String name = "deferred";
-    LibraryIdentifier identifier = parseLibraryIdentifier(name);
-    expectNotNullIfNoErrors(identifier);
-    assertNoErrors();
-    expect(identifier.name, name);
-    expect(identifier.beginToken.type.isBuiltIn, isTrue);
-  }
-
-  void test_parseLibraryIdentifier_invalid() {
-    parseCompilationUnit('library <myLibId>;', errors: [
-      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 0, 7),
-      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 17, 1),
-    ]);
-  }
-
-  void test_parseLibraryIdentifier_multiple() {
-    String name = "a.b.c";
-    LibraryIdentifier identifier = parseLibraryIdentifier(name);
-    expectNotNullIfNoErrors(identifier);
-    assertNoErrors();
-    expect(identifier.name, name);
-  }
-
-  void test_parseLibraryIdentifier_pseudo() {
-    String name = "await";
-    LibraryIdentifier identifier = parseLibraryIdentifier(name);
-    expectNotNullIfNoErrors(identifier);
-    assertNoErrors();
-    expect(identifier.name, name);
-    expect(identifier.beginToken.type.isPseudo, isTrue);
-  }
-
-  void test_parseLibraryIdentifier_single() {
-    String name = "a";
-    LibraryIdentifier identifier = parseLibraryIdentifier(name);
-    expectNotNullIfNoErrors(identifier);
-    assertNoErrors();
-    expect(identifier.name, name);
-  }
-
-  void test_parseOptionalReturnType() {
-    // TODO(brianwilkerson) Implement tests for this method.
-  }
-
-  void test_parseReturnStatement_noValue() {
-    ReturnStatement statement = parseStatement('return;');
-    expectNotNullIfNoErrors(statement);
-    assertNoErrors();
-    expect(statement.returnKeyword, isNotNull);
-    expect(statement.expression, isNull);
-    expect(statement.semicolon, isNotNull);
-  }
-
-  void test_parseReturnStatement_value() {
-    ReturnStatement statement = parseStatement('return x;');
-    expectNotNullIfNoErrors(statement);
-    assertNoErrors();
-    expect(statement.returnKeyword, isNotNull);
-    expect(statement.expression, isNotNull);
-    expect(statement.semicolon, isNotNull);
-  }
-
-  void test_parseStatement_function_noReturnType() {
-    createParser('''
-Function<A>(core.List<core.int> x) m() => null;
-''');
-    Statement statement = parser.parseStatement2();
-    expect(statement, isFunctionDeclarationStatement);
-    expect(
-        (statement as FunctionDeclarationStatement)
-            .functionDeclaration
-            .functionExpression
-            .body,
-        isExpressionFunctionBody);
-  }
-
-  void test_parseStatements_multiple() {
-    parseStatementList("return; return;", 2);
-  }
-
-  void test_parseStatements_single() {
-    parseStatementList("return;", 1);
-  }
-
-  void test_parseTypeAnnotation_function_noReturnType_noParameters() {
-    createParser('Function()');
-    GenericFunctionType functionType = parser.parseTypeAnnotation(false);
-    expectNotNullIfNoErrors(functionType);
-    assertNoErrors();
-    expect(functionType.returnType, isNull);
-    expect(functionType.functionKeyword, isNotNull);
-    expect(functionType.typeParameters, isNull);
-    FormalParameterList parameterList = functionType.parameters;
-    expect(parameterList, isNotNull);
-    expect(parameterList.parameters, hasLength(0));
-  }
-
-  void test_parseTypeAnnotation_function_noReturnType_parameters() {
-    createParser('Function(int, int)');
-    GenericFunctionType functionType = parser.parseTypeAnnotation(false);
-    expectNotNullIfNoErrors(functionType);
-    assertNoErrors();
-    expect(functionType.returnType, isNull);
-    expect(functionType.functionKeyword, isNotNull);
-    expect(functionType.typeParameters, isNull);
-    FormalParameterList parameterList = functionType.parameters;
-    expect(parameterList, isNotNull);
-    NodeList<FormalParameter> parameters = parameterList.parameters;
-    expect(parameters, hasLength(2));
-
-    expect(parameters[0], isSimpleFormalParameter);
-    SimpleFormalParameter parameter = parameters[0];
-    expect(parameter.identifier, isNull);
-    expect(parameter.type, isTypeName);
-    expect((parameter.type as TypeName).name.name, 'int');
-
-    expect(parameters[1], isSimpleFormalParameter);
-    parameter = parameters[1];
-    expect(parameter.identifier, isNull);
-    expect(parameter.type, isTypeName);
-    expect((parameter.type as TypeName).name.name, 'int');
-  }
-
-  void test_parseTypeAnnotation_function_noReturnType_typeParameters() {
-    createParser('Function<S, T>()');
-    GenericFunctionType functionType = parser.parseTypeAnnotation(false);
-    expectNotNullIfNoErrors(functionType);
-    assertNoErrors();
-    expect(functionType.returnType, isNull);
-    expect(functionType.functionKeyword, isNotNull);
-    TypeParameterList typeParameters = functionType.typeParameters;
-    expect(typeParameters, isNotNull);
-    expect(typeParameters.typeParameters, hasLength(2));
-    FormalParameterList parameterList = functionType.parameters;
-    expect(parameterList, isNotNull);
-    expect(parameterList.parameters, hasLength(0));
-  }
-
-  void
-      test_parseTypeAnnotation_function_noReturnType_typeParameters_parameters() {
-    createParser('Function<T>(String, {T t})');
-    GenericFunctionType functionType = parser.parseTypeAnnotation(false);
-    expectNotNullIfNoErrors(functionType);
-    assertNoErrors();
-    expect(functionType.returnType, isNull);
-    expect(functionType.functionKeyword, isNotNull);
-    TypeParameterList typeParameters = functionType.typeParameters;
-    expect(typeParameters, isNotNull);
-    expect(typeParameters.typeParameters, hasLength(1));
-    FormalParameterList parameterList = functionType.parameters;
-    expect(parameterList, isNotNull);
-    expect(parameterList.parameters, hasLength(2));
-  }
-
-  void test_parseTypeAnnotation_function_returnType_classFunction() {
-    createParser('Function');
-    TypeName functionType = parser.parseTypeAnnotation(false);
-    expectNotNullIfNoErrors(functionType);
-    assertNoErrors();
-  }
-
-  void test_parseTypeAnnotation_function_returnType_function() {
-    createParser('A Function(B, C) Function(D)');
-    // TODO(scheglov) improve the test to verify also the node properties
-    var functionType = parser.parseTypeAnnotation(false) as GenericFunctionType;
-    expectNotNullIfNoErrors(functionType);
-    assertNoErrors();
-  }
-
-  void test_parseTypeAnnotation_function_returnType_noParameters() {
-    createParser('List<int> Function()');
-    GenericFunctionType functionType = parser.parseTypeAnnotation(false);
-    expectNotNullIfNoErrors(functionType);
-    assertNoErrors();
-    expect(functionType.returnType, isNotNull);
-    expect(functionType.functionKeyword, isNotNull);
-    expect(functionType.typeParameters, isNull);
-    FormalParameterList parameterList = functionType.parameters;
-    expect(parameterList, isNotNull);
-    expect(parameterList.parameters, hasLength(0));
-  }
-
-  void test_parseTypeAnnotation_function_returnType_parameters() {
-    createParser('List<int> Function(String s, int i)');
-    GenericFunctionType functionType = parser.parseTypeAnnotation(false);
-    expectNotNullIfNoErrors(functionType);
-    assertNoErrors();
-    expect(functionType.returnType, isNotNull);
-    expect(functionType.functionKeyword, isNotNull);
-    expect(functionType.typeParameters, isNull);
-    FormalParameterList parameterList = functionType.parameters;
-    expect(parameterList, isNotNull);
-    NodeList<FormalParameter> parameters = parameterList.parameters;
-    expect(parameters, hasLength(2));
-
-    expect(parameters[0], isSimpleFormalParameter);
-    SimpleFormalParameter parameter = parameters[0];
-    expect(parameter.identifier, isNotNull);
-    expect(parameter.identifier.name, 's');
-    expect(parameter.type, isTypeName);
-    expect((parameter.type as TypeName).name.name, 'String');
-
-    expect(parameters[1], isSimpleFormalParameter);
-    parameter = parameters[1];
-    expect(parameter.identifier, isNotNull);
-    expect(parameter.identifier.name, 'i');
-    expect(parameter.type, isTypeName);
-    expect((parameter.type as TypeName).name.name, 'int');
-  }
-
-  void test_parseTypeAnnotation_function_returnType_simple() {
-    createParser('A Function(B, C)');
-    // TODO(scheglov) improve the test to verify also the node properties
-    var functionType = parser.parseTypeAnnotation(false) as GenericFunctionType;
-    expectNotNullIfNoErrors(functionType);
-    assertNoErrors();
-  }
-
-  void test_parseTypeAnnotation_function_returnType_typeParameters() {
-    createParser('List<T> Function<T>()');
-    GenericFunctionType functionType = parser.parseTypeAnnotation(false);
-    expectNotNullIfNoErrors(functionType);
-    assertNoErrors();
-    expect(functionType.returnType, isNotNull);
-    expect(functionType.functionKeyword, isNotNull);
-    TypeParameterList typeParameters = functionType.typeParameters;
-    expect(typeParameters, isNotNull);
-    expect(typeParameters.typeParameters, hasLength(1));
-    FormalParameterList parameterList = functionType.parameters;
-    expect(parameterList, isNotNull);
-    expect(parameterList.parameters, hasLength(0));
-  }
-
-  void
-      test_parseTypeAnnotation_function_returnType_typeParameters_parameters() {
-    createParser('List<T> Function<T>(String s, [T])');
-    GenericFunctionType functionType = parser.parseTypeAnnotation(false);
-    expectNotNullIfNoErrors(functionType);
-    assertNoErrors();
-    expect(functionType.returnType, isNotNull);
-    expect(functionType.functionKeyword, isNotNull);
-    TypeParameterList typeParameters = functionType.typeParameters;
-    expect(typeParameters, isNotNull);
-    expect(typeParameters.typeParameters, hasLength(1));
-    FormalParameterList parameterList = functionType.parameters;
-    expect(parameterList, isNotNull);
-    expect(parameterList.parameters, hasLength(2));
-  }
-
-  void test_parseTypeAnnotation_function_returnType_withArguments() {
-    createParser('A<B> Function(C)');
-    // TODO(scheglov) improve this test to verify also the node properties
-    var functionType = parser.parseTypeAnnotation(false) as GenericFunctionType;
-    expectNotNullIfNoErrors(functionType);
-    assertNoErrors();
-  }
-
-  void test_parseTypeAnnotation_named() {
-    createParser('A<B>');
-    TypeName typeName = parser.parseTypeAnnotation(false);
-    expectNotNullIfNoErrors(typeName);
-    assertNoErrors();
-  }
-
-  void test_parseTypeArgumentList_empty() {
-    createParser('<>');
-    TypeArgumentList argumentList = parser.parseTypeArgumentList();
-    expectNotNullIfNoErrors(argumentList);
-    listener.assertErrorsWithCodes([ParserErrorCode.EXPECTED_TYPE_NAME]);
-    expect(argumentList.leftBracket, isNotNull);
-    expect(argumentList.arguments, hasLength(1));
-    expect(argumentList.rightBracket, isNotNull);
-  }
-
-  void test_parseTypeArgumentList_multiple() {
-    createParser('<int, int, int>');
-    TypeArgumentList argumentList = parser.parseTypeArgumentList();
-    expectNotNullIfNoErrors(argumentList);
-    assertNoErrors();
-    expect(argumentList.leftBracket, isNotNull);
-    expect(argumentList.arguments, hasLength(3));
-    expect(argumentList.rightBracket, isNotNull);
-  }
-
-  void test_parseTypeArgumentList_nested() {
-    createParser('<A<B>>');
-    TypeArgumentList argumentList = parser.parseTypeArgumentList();
-    expectNotNullIfNoErrors(argumentList);
-    assertNoErrors();
-    expect(argumentList.leftBracket, isNotNull);
-    expect(argumentList.arguments, hasLength(1));
-    TypeName argument = argumentList.arguments[0];
-    expect(argument, isNotNull);
-    TypeArgumentList innerList = argument.typeArguments;
-    expect(innerList, isNotNull);
-    expect(innerList.arguments, hasLength(1));
-    expect(argumentList.rightBracket, isNotNull);
-  }
-
-  void test_parseTypeArgumentList_nested_withComment_double() {
-    createParser('<A<B /* 0 */ >>');
-    TypeArgumentList argumentList = parser.parseTypeArgumentList();
-    expectNotNullIfNoErrors(argumentList);
-    assertNoErrors();
-    expect(argumentList.leftBracket, isNotNull);
-    expect(argumentList.rightBracket, isNotNull);
-    expect(argumentList.arguments, hasLength(1));
-
-    TypeName argument = argumentList.arguments[0];
-    expect(argument, isNotNull);
-
-    TypeArgumentList innerList = argument.typeArguments;
-    expect(innerList, isNotNull);
-    expect(innerList.leftBracket, isNotNull);
-    expect(innerList.arguments, hasLength(1));
-    expect(innerList.rightBracket, isNotNull);
-    expect(innerList.rightBracket.precedingComments, isNotNull);
-  }
-
-  void test_parseTypeArgumentList_nested_withComment_tripple() {
-    createParser('<A<B<C /* 0 */ >>>');
-    TypeArgumentList argumentList = parser.parseTypeArgumentList();
-    expectNotNullIfNoErrors(argumentList);
-    assertNoErrors();
-    expect(argumentList.leftBracket, isNotNull);
-    expect(argumentList.rightBracket, isNotNull);
-    expect(argumentList.arguments, hasLength(1));
-
-    TypeName argument = argumentList.arguments[0];
-    expect(argument, isNotNull);
-
-    TypeArgumentList innerList = argument.typeArguments;
-    expect(innerList, isNotNull);
-    expect(innerList.leftBracket, isNotNull);
-    expect(innerList.arguments, hasLength(1));
-    expect(innerList.rightBracket, isNotNull);
-
-    TypeName innerArgument = innerList.arguments[0];
-    expect(innerArgument, isNotNull);
-
-    TypeArgumentList innerInnerList = innerArgument.typeArguments;
-    expect(innerInnerList, isNotNull);
-    expect(innerInnerList.leftBracket, isNotNull);
-    expect(innerInnerList.arguments, hasLength(1));
-    expect(innerInnerList.rightBracket, isNotNull);
-    expect(innerInnerList.rightBracket.precedingComments, isNotNull);
-  }
-
-  void test_parseTypeArgumentList_single() {
-    createParser('<int>');
-    TypeArgumentList argumentList = parser.parseTypeArgumentList();
-    expectNotNullIfNoErrors(argumentList);
-    assertNoErrors();
-    expect(argumentList.leftBracket, isNotNull);
-    expect(argumentList.arguments, hasLength(1));
-    expect(argumentList.rightBracket, isNotNull);
-  }
-
-  void test_parseTypeName_parameterized() {
-    createParser('List<int>');
-    TypeName typeName = parser.parseTypeName(false);
-    expectNotNullIfNoErrors(typeName);
-    assertNoErrors();
-    expect(typeName.name, isNotNull);
-    expect(typeName.typeArguments, isNotNull);
-  }
-
-  void test_parseTypeName_simple() {
-    createParser('int');
-    TypeName typeName = parser.parseTypeName(false);
-    expectNotNullIfNoErrors(typeName);
-    assertNoErrors();
-    expect(typeName.name, isNotNull);
-    expect(typeName.typeArguments, isNull);
-  }
-
-  void test_parseTypeParameter_bounded_functionType_noReturn() {
-    createParser('A extends Function(int)');
-    TypeParameter parameter = parser.parseTypeParameter();
-    expectNotNullIfNoErrors(parameter);
-    assertNoErrors();
-    expect(parameter.bound, isGenericFunctionType);
-    expect(parameter.extendsKeyword, isNotNull);
-    expect(parameter.name, isNotNull);
-  }
-
-  void test_parseTypeParameter_bounded_functionType_return() {
-    createParser('A extends String Function(int)');
-    TypeParameter parameter = parser.parseTypeParameter();
-    expectNotNullIfNoErrors(parameter);
-    assertNoErrors();
-    expect(parameter.bound, isGenericFunctionType);
-    expect(parameter.extendsKeyword, isNotNull);
-    expect(parameter.name, isNotNull);
-  }
-
-  void test_parseTypeParameter_bounded_generic() {
-    createParser('A extends B<C>');
-    TypeParameter parameter = parser.parseTypeParameter();
-    expectNotNullIfNoErrors(parameter);
-    assertNoErrors();
-    expect(parameter.bound, isTypeName);
-    expect(parameter.extendsKeyword, isNotNull);
-    expect(parameter.name, isNotNull);
-  }
-
-  void test_parseTypeParameter_bounded_simple() {
-    createParser('A extends B');
-    TypeParameter parameter = parser.parseTypeParameter();
-    expectNotNullIfNoErrors(parameter);
-    assertNoErrors();
-    expect(parameter.bound, isTypeName);
-    expect(parameter.extendsKeyword, isNotNull);
-    expect(parameter.name, isNotNull);
-  }
-
-  void test_parseTypeParameter_simple() {
-    createParser('A');
-    TypeParameter parameter = parser.parseTypeParameter();
-    expectNotNullIfNoErrors(parameter);
-    assertNoErrors();
-    expect(parameter.bound, isNull);
-    expect(parameter.extendsKeyword, isNull);
-    expect(parameter.name, isNotNull);
-  }
-
-  void test_parseTypeParameterList_multiple() {
-    createParser('<A, B extends C, D>');
-    TypeParameterList parameterList = parser.parseTypeParameterList();
-    expectNotNullIfNoErrors(parameterList);
-    assertNoErrors();
-    expect(parameterList.leftBracket, isNotNull);
-    expect(parameterList.rightBracket, isNotNull);
-    expect(parameterList.typeParameters, hasLength(3));
-  }
-
-  void test_parseTypeParameterList_parameterizedWithTrailingEquals() {
-    createParser('<A extends B<E>>=', expectedEndOffset: 16);
-    TypeParameterList parameterList = parser.parseTypeParameterList();
-    expectNotNullIfNoErrors(parameterList);
-    assertNoErrors();
-    expect(parameterList.leftBracket, isNotNull);
-    expect(parameterList.rightBracket, isNotNull);
-    expect(parameterList.typeParameters, hasLength(1));
-  }
-
-  void test_parseTypeParameterList_parameterizedWithTrailingEquals2() {
-    createParser('<A extends B<E /* foo */ >>=', expectedEndOffset: 27);
-    TypeParameterList parameterList = parser.parseTypeParameterList();
-    expectNotNullIfNoErrors(parameterList);
-    assertNoErrors();
-    expect(parameterList.leftBracket, isNotNull);
-    expect(parameterList.rightBracket, isNotNull);
-    expect(parameterList.typeParameters, hasLength(1));
-    TypeParameter typeParameter = parameterList.typeParameters[0];
-    expect(typeParameter.name.name, 'A');
-    TypeName bound = typeParameter.bound;
-    expect(bound.name.name, 'B');
-    TypeArgumentList typeArguments = bound.typeArguments;
-    expect(typeArguments.arguments, hasLength(1));
-    expect(typeArguments.rightBracket, isNotNull);
-    expect(typeArguments.rightBracket.precedingComments.lexeme, '/* foo */');
-    TypeName argument = typeArguments.arguments[0];
-    expect(argument.name.name, 'E');
-  }
-
-  void test_parseTypeParameterList_single() {
-    createParser('<<A>', expectedEndOffset: 0);
-    TypeParameterList parameterList = parser.parseTypeParameterList();
-    // TODO(danrubel): Consider splitting `<<` and marking the first `<`
-    // as an unexpected token.
-    expect(parameterList, isNull);
-    assertNoErrors();
-  }
-
-  void test_parseTypeParameterList_withTrailingEquals() {
-    createParser('<A>=', expectedEndOffset: 3);
-    TypeParameterList parameterList = parser.parseTypeParameterList();
-    expectNotNullIfNoErrors(parameterList);
-    assertNoErrors();
-    expect(parameterList.leftBracket, isNotNull);
-    expect(parameterList.rightBracket, isNotNull);
-    expect(parameterList.typeParameters, hasLength(1));
-  }
-
-  void test_parseVariableDeclaration_equals() {
-    VariableDeclaration declaration = parseVariableDeclaration('var a = b;');
-    expectNotNullIfNoErrors(declaration);
-    assertNoErrors();
-    expect(declaration.name, isNotNull);
-    expect(declaration.equals, isNotNull);
-    expect(declaration.initializer, isNotNull);
-  }
-
-  void test_parseVariableDeclaration_noEquals() {
-    VariableDeclaration declaration = parseVariableDeclaration('var a;');
-    expectNotNullIfNoErrors(declaration);
-    assertNoErrors();
-    expect(declaration.name, isNotNull);
-    expect(declaration.equals, isNull);
-    expect(declaration.initializer, isNull);
-  }
-
-  void test_parseWithClause_multiple() {
-    WithClause clause = parseWithClause('with A, B, C');
-    expectNotNullIfNoErrors(clause);
-    assertNoErrors();
-    expect(clause.withKeyword, isNotNull);
-    expect(clause.mixinTypes, hasLength(3));
-  }
-
-  void test_parseWithClause_single() {
-    WithClause clause = parseWithClause('with M');
-    expectNotNullIfNoErrors(clause);
-    assertNoErrors();
-    expect(clause.withKeyword, isNotNull);
-    expect(clause.mixinTypes, hasLength(1));
-  }
-}
-
-/// The class [FormalParameterParserTestMixin] defines parser tests that test
-/// the parsing statements.
-mixin StatementParserTestMixin implements AbstractParserTestCase {
-  void test_invalid_typeParamAnnotation() {
-    parseCompilationUnit('main() { C<@Foo T> v; }', errors: [
-      expectedError(ParserErrorCode.ANNOTATION_ON_TYPE_ARGUMENT, 11, 4)
-    ]);
-  }
-
-  void test_invalid_typeParamAnnotation2() {
-    parseCompilationUnit('main() { C<@Foo.bar(1) T> v; }', errors: [
-      expectedError(ParserErrorCode.ANNOTATION_ON_TYPE_ARGUMENT, 11, 11)
-    ]);
-  }
-
-  void test_invalid_typeParamAnnotation3() {
-    parseCompilationUnit('''
-main() {
-  C<@Foo.bar(const [], const [1], const{"":r""}, 0xFF + 2, .3, 4.5) T,
-    F Function<G>(int, String, {Bar b}),
-    void Function<H>(int i, [String j, K]),
-    A<B<C>>,
-    W<X<Y<Z>>>
-  > v;
-}''', errors: [
-      expectedError(ParserErrorCode.ANNOTATION_ON_TYPE_ARGUMENT, 13, 63)
-    ]);
-  }
-
-  void test_parseAssertStatement() {
-    var statement = parseStatement('assert (x);') as AssertStatement;
-    assertNoErrors();
-    expect(statement.assertKeyword, isNotNull);
-    expect(statement.leftParenthesis, isNotNull);
-    expect(statement.condition, isNotNull);
-    expect(statement.comma, isNull);
-    expect(statement.message, isNull);
-    expect(statement.rightParenthesis, isNotNull);
-    expect(statement.semicolon, isNotNull);
-  }
-
-  void test_parseAssertStatement_messageLowPrecedence() {
-    // Using a throw expression as an assert message would be silly in
-    // practice, but it's the lowest precedence expression type, so verifying
-    // that it works should give us high confidence that other expression types
-    // will work as well.
-    var statement =
-        parseStatement('assert (x, throw "foo");') as AssertStatement;
-    assertNoErrors();
-    expect(statement.assertKeyword, isNotNull);
-    expect(statement.leftParenthesis, isNotNull);
-    expect(statement.condition, isNotNull);
-    expect(statement.comma, isNotNull);
-    expect(statement.message, isNotNull);
-    expect(statement.rightParenthesis, isNotNull);
-    expect(statement.semicolon, isNotNull);
-  }
-
-  void test_parseAssertStatement_messageString() {
-    var statement = parseStatement('assert (x, "foo");') as AssertStatement;
-    assertNoErrors();
-    expect(statement.assertKeyword, isNotNull);
-    expect(statement.leftParenthesis, isNotNull);
-    expect(statement.condition, isNotNull);
-    expect(statement.comma, isNotNull);
-    expect(statement.message, isNotNull);
-    expect(statement.rightParenthesis, isNotNull);
-    expect(statement.semicolon, isNotNull);
-  }
-
-  void test_parseAssertStatement_trailingComma_message() {
-    var statement = parseStatement('assert (x, "m",);') as AssertStatement;
-    assertNoErrors();
-    expect(statement.assertKeyword, isNotNull);
-    expect(statement.leftParenthesis, isNotNull);
-    expect(statement.condition, isNotNull);
-    expect(statement.comma, isNotNull);
-    expect(statement.message, isNotNull);
-    expect(statement.rightParenthesis, isNotNull);
-    expect(statement.semicolon, isNotNull);
-  }
-
-  void test_parseAssertStatement_trailingComma_noMessage() {
-    var statement = parseStatement('assert (x,);') as AssertStatement;
-    assertNoErrors();
-    expect(statement.assertKeyword, isNotNull);
-    expect(statement.leftParenthesis, isNotNull);
-    expect(statement.condition, isNotNull);
-    expect(statement.comma, isNull);
-    expect(statement.message, isNull);
-    expect(statement.rightParenthesis, isNotNull);
-    expect(statement.semicolon, isNotNull);
-  }
-
-  void test_parseBlock_empty() {
-    var block = parseStatement('{}') as Block;
-    assertNoErrors();
-    expect(block.leftBracket, isNotNull);
-    expect(block.statements, hasLength(0));
-    expect(block.rightBracket, isNotNull);
-  }
-
-  void test_parseBlock_nonEmpty() {
-    var block = parseStatement('{;}') as Block;
-    assertNoErrors();
-    expect(block.leftBracket, isNotNull);
-    expect(block.statements, hasLength(1));
-    expect(block.rightBracket, isNotNull);
-  }
-
-  void test_parseBreakStatement_label() {
-    LabeledStatement labeledStatement =
-        parseStatement('foo: while (true) { break foo; }');
-    WhileStatement whileStatement = labeledStatement.statement;
-    BreakStatement statement = (whileStatement.body as Block).statements[0];
-    assertNoErrors();
-    expect(statement.breakKeyword, isNotNull);
-    expect(statement.label, isNotNull);
-    expect(statement.semicolon, isNotNull);
-  }
-
-  void test_parseBreakStatement_noLabel() {
-    WhileStatement whileStatement = parseStatement('while (true) { break; }');
-    BreakStatement statement = (whileStatement.body as Block).statements[0];
-    assertNoErrors();
-    expect(statement.breakKeyword, isNotNull);
-    expect(statement.label, isNull);
-    expect(statement.semicolon, isNotNull);
-  }
-
-  void test_parseContinueStatement_label() {
-    LabeledStatement labeledStatement =
-        parseStatement('foo: while (true) { continue foo; }');
-    WhileStatement whileStatement = labeledStatement.statement;
-    ContinueStatement statement = (whileStatement.body as Block).statements[0];
-    assertNoErrors();
-    expect(statement.continueKeyword, isNotNull);
-    expect(statement.label, isNotNull);
-    expect(statement.semicolon, isNotNull);
-  }
-
-  void test_parseContinueStatement_noLabel() {
-    WhileStatement whileStatement =
-        parseStatement('while (true) { continue; }');
-    ContinueStatement statement = (whileStatement.body as Block).statements[0];
-    assertNoErrors();
-    expect(statement.continueKeyword, isNotNull);
-    expect(statement.label, isNull);
-    expect(statement.semicolon, isNotNull);
-  }
-
-  void test_parseDoStatement() {
-    var statement = parseStatement('do {} while (x);') as DoStatement;
-    assertNoErrors();
-    expect(statement.doKeyword, isNotNull);
-    expect(statement.body, isNotNull);
-    expect(statement.whileKeyword, isNotNull);
-    expect(statement.leftParenthesis, isNotNull);
-    expect(statement.condition, isNotNull);
-    expect(statement.rightParenthesis, isNotNull);
-    expect(statement.semicolon, isNotNull);
-  }
-
-  void test_parseElseAlone() {
-    parseCompilationUnit('main() { else return 0; } ', errors: [
-      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 9, 4),
-      expectedError(ParserErrorCode.EXPECTED_TOKEN, 9, 4),
-      expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 9, 4),
-    ]);
-  }
-
-  void test_parseEmptyStatement() {
-    var statement = parseStatement(';') as EmptyStatement;
-    assertNoErrors();
-    expect(statement.semicolon, isNotNull);
-  }
-
-  void test_parseForStatement_each_await() {
-    // TODO(danrubel): remove this once control flow and spread collection
-    // entry parsing is enabled by default
-    String code = 'await for (element in list) {}';
-    var forStatement = _parseAsyncStatement(code) as ForStatement;
-    assertNoErrors();
-    expect(forStatement.awaitKeyword, isNotNull);
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    var forEachParts = forStatement.forLoopParts as ForEachPartsWithIdentifier;
-    expect(forEachParts.identifier, isNotNull);
-    expect(forEachParts.inKeyword, isNotNull);
-    expect(forEachParts.iterable, isNotNull);
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_each_genericFunctionType() {
-    // TODO(danrubel): remove this once control flow and spread collection
-    // entry parsing is enabled by default
-    var forStatement =
-        parseStatement('for (void Function<T>(T) element in list) {}')
-            as ForStatement;
-    assertNoErrors();
-    expect(forStatement.awaitKeyword, isNull);
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    var forEachParts = forStatement.forLoopParts as ForEachPartsWithDeclaration;
-    expect(forEachParts.loopVariable, isNotNull);
-    expect(forEachParts.inKeyword, isNotNull);
-    expect(forEachParts.iterable, isNotNull);
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_each_identifier() {
-    // TODO(danrubel): remove this once control flow and spread collection
-    // entry parsing is enabled by default
-    var forStatement =
-        parseStatement('for (element in list) {}') as ForStatement;
-    assertNoErrors();
-    expect(forStatement.awaitKeyword, isNull);
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    var forEachParts = forStatement.forLoopParts as ForEachPartsWithIdentifier;
-    expect(forEachParts.identifier, isNotNull);
-    expect(forEachParts.inKeyword, isNotNull);
-    expect(forEachParts.iterable, isNotNull);
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_each_noType_metadata() {
-    // TODO(danrubel): remove this once control flow and spread collection
-    // entry parsing is enabled by default
-    var forStatement =
-        parseStatement('for (@A var element in list) {}') as ForStatement;
-    assertNoErrors();
-    expect(forStatement.awaitKeyword, isNull);
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    var forEachParts = forStatement.forLoopParts as ForEachPartsWithDeclaration;
-    expect(forEachParts.loopVariable, isNotNull);
-    expect(forEachParts.loopVariable.metadata, hasLength(1));
-    expect(forEachParts.inKeyword, isNotNull);
-    expect(forEachParts.iterable, isNotNull);
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_each_type() {
-    // TODO(danrubel): remove this once control flow and spread collection
-    // entry parsing is enabled by default
-    var forStatement =
-        parseStatement('for (A element in list) {}') as ForStatement;
-    assertNoErrors();
-    expect(forStatement.awaitKeyword, isNull);
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    var forEachParts = forStatement.forLoopParts as ForEachPartsWithDeclaration;
-    expect(forEachParts.loopVariable, isNotNull);
-    expect(forEachParts.inKeyword, isNotNull);
-    expect(forEachParts.iterable, isNotNull);
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_each_var() {
-    // TODO(danrubel): remove this once control flow and spread collection
-    // entry parsing is enabled by default
-    var forStatement =
-        parseStatement('for (var element in list) {}') as ForStatement;
-    assertNoErrors();
-    expect(forStatement.awaitKeyword, isNull);
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    var forEachParts = forStatement.forLoopParts as ForEachPartsWithDeclaration;
-    expect(forEachParts.loopVariable, isNotNull);
-    expect(forEachParts.inKeyword, isNotNull);
-    expect(forEachParts.iterable, isNotNull);
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_loop_c() {
-    // TODO(danrubel): remove this once control flow and spread collection
-    // entry parsing is enabled by default
-    var forStatement = parseStatement('for (; i < count;) {}') as ForStatement;
-    assertNoErrors();
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    var forParts = forStatement.forLoopParts as ForPartsWithExpression;
-    expect(forParts.initialization, isNull);
-    expect(forParts.leftSeparator, isNotNull);
-    expect(forParts.condition, isNotNull);
-    expect(forParts.rightSeparator, isNotNull);
-    expect(forParts.updaters, hasLength(0));
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_loop_cu() {
-    // TODO(danrubel): remove this once control flow and spread collection
-    // entry parsing is enabled by default
-    var forStatement =
-        parseStatement('for (; i < count; i++) {}') as ForStatement;
-    assertNoErrors();
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    var forParts = forStatement.forLoopParts as ForPartsWithExpression;
-    expect(forParts.initialization, isNull);
-    expect(forParts.leftSeparator, isNotNull);
-    expect(forParts.condition, isNotNull);
-    expect(forParts.rightSeparator, isNotNull);
-    expect(forParts.updaters, hasLength(1));
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_loop_ecu() {
-    // TODO(danrubel): remove this once control flow and spread collection
-    // entry parsing is enabled by default
-    var forStatement =
-        parseStatement('for (i--; i < count; i++) {}') as ForStatement;
-    assertNoErrors();
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    var forParts = forStatement.forLoopParts as ForPartsWithExpression;
-    expect(forParts.initialization, isNotNull);
-    expect(forParts.leftSeparator, isNotNull);
-    expect(forParts.condition, isNotNull);
-    expect(forParts.rightSeparator, isNotNull);
-    expect(forParts.updaters, hasLength(1));
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_loop_i() {
-    // TODO(danrubel): remove this once control flow and spread collection
-    // entry parsing is enabled by default
-    var forStatement = parseStatement('for (var i = 0;;) {}') as ForStatement;
-    assertNoErrors();
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    var forParts = forStatement.forLoopParts as ForPartsWithDeclarations;
-    VariableDeclarationList variables = forParts.variables;
-    expect(variables, isNotNull);
-    expect(variables.metadata, hasLength(0));
-    expect(variables.variables, hasLength(1));
-    expect(forParts.leftSeparator, isNotNull);
-    expect(forParts.condition, isNull);
-    expect(forParts.rightSeparator, isNotNull);
-    expect(forParts.updaters, hasLength(0));
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_loop_i_withMetadata() {
-    // TODO(danrubel): remove this once control flow and spread collection
-    // entry parsing is enabled by default
-    var forStatement =
-        parseStatement('for (@A var i = 0;;) {}') as ForStatement;
-    assertNoErrors();
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    var forParts = forStatement.forLoopParts as ForPartsWithDeclarations;
-    VariableDeclarationList variables = forParts.variables;
-    expect(variables, isNotNull);
-    expect(variables.metadata, hasLength(1));
-    expect(variables.variables, hasLength(1));
-    expect(forParts.leftSeparator, isNotNull);
-    expect(forParts.condition, isNull);
-    expect(forParts.rightSeparator, isNotNull);
-    expect(forParts.updaters, hasLength(0));
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_loop_ic() {
-    // TODO(danrubel): remove this once control flow and spread collection
-    // entry parsing is enabled by default
-    var forStatement =
-        parseStatement('for (var i = 0; i < count;) {}') as ForStatement;
-    assertNoErrors();
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    var forParts = forStatement.forLoopParts as ForPartsWithDeclarations;
-    VariableDeclarationList variables = forParts.variables;
-    expect(variables, isNotNull);
-    expect(variables.variables, hasLength(1));
-    expect(forParts.leftSeparator, isNotNull);
-    expect(forParts.condition, isNotNull);
-    expect(forParts.rightSeparator, isNotNull);
-    expect(forParts.updaters, hasLength(0));
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_loop_icu() {
-    // TODO(danrubel): remove this once control flow and spread collection
-    // entry parsing is enabled by default
-    var forStatement =
-        parseStatement('for (var i = 0; i < count; i++) {}') as ForStatement;
-    assertNoErrors();
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    var forParts = forStatement.forLoopParts as ForPartsWithDeclarations;
-    VariableDeclarationList variables = forParts.variables;
-    expect(variables, isNotNull);
-    expect(variables.variables, hasLength(1));
-    expect(forParts.leftSeparator, isNotNull);
-    expect(forParts.condition, isNotNull);
-    expect(forParts.rightSeparator, isNotNull);
-    expect(forParts.updaters, hasLength(1));
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_loop_iicuu() {
-    // TODO(danrubel): remove this once control flow and spread collection
-    // entry parsing is enabled by default
-    var forStatement =
-        parseStatement('for (int i = 0, j = count; i < j; i++, j--) {}')
-            as ForStatement;
-    assertNoErrors();
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    var forParts = forStatement.forLoopParts as ForPartsWithDeclarations;
-    VariableDeclarationList variables = forParts.variables;
-    expect(variables, isNotNull);
-    expect(variables.variables, hasLength(2));
-    expect(forParts.leftSeparator, isNotNull);
-    expect(forParts.condition, isNotNull);
-    expect(forParts.rightSeparator, isNotNull);
-    expect(forParts.updaters, hasLength(2));
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_loop_iu() {
-    // TODO(danrubel): remove this once control flow and spread collection
-    // entry parsing is enabled by default
-    var forStatement =
-        parseStatement('for (var i = 0;; i++) {}') as ForStatement;
-    assertNoErrors();
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    var forParts = forStatement.forLoopParts as ForPartsWithDeclarations;
-    VariableDeclarationList variables = forParts.variables;
-    expect(variables, isNotNull);
-    expect(variables.variables, hasLength(1));
-    expect(forParts.leftSeparator, isNotNull);
-    expect(forParts.condition, isNull);
-    expect(forParts.rightSeparator, isNotNull);
-    expect(forParts.updaters, hasLength(1));
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseForStatement_loop_u() {
-    // TODO(danrubel): remove this once control flow and spread collection
-    // entry parsing is enabled by default
-    var forStatement = parseStatement('for (;; i++) {}') as ForStatement;
-    assertNoErrors();
-    expect(forStatement.forKeyword, isNotNull);
-    expect(forStatement.leftParenthesis, isNotNull);
-    var forParts = forStatement.forLoopParts as ForPartsWithExpression;
-    expect(forParts.initialization, isNull);
-    expect(forParts.leftSeparator, isNotNull);
-    expect(forParts.condition, isNull);
-    expect(forParts.rightSeparator, isNotNull);
-    expect(forParts.updaters, hasLength(1));
-    expect(forStatement.rightParenthesis, isNotNull);
-    expect(forStatement.body, isNotNull);
-  }
-
-  void test_parseFunctionDeclarationStatement() {
-    var statement = parseStatement('void f(int p) => p * 2;')
-        as FunctionDeclarationStatement;
-    assertNoErrors();
-    expect(statement.functionDeclaration, isNotNull);
-  }
-
-  void test_parseFunctionDeclarationStatement_typeParameters() {
-    var statement =
-        parseStatement('E f<E>(E p) => p * 2;') as FunctionDeclarationStatement;
-    assertNoErrors();
-    expect(statement.functionDeclaration, isNotNull);
-    expect(statement.functionDeclaration.functionExpression.typeParameters,
-        isNotNull);
-  }
-
-  void test_parseFunctionDeclarationStatement_typeParameters_noReturnType() {
-    var statement =
-        parseStatement('f<E>(E p) => p * 2;') as FunctionDeclarationStatement;
-    assertNoErrors();
-    expect(statement.functionDeclaration, isNotNull);
-    expect(statement.functionDeclaration.functionExpression.typeParameters,
-        isNotNull);
-  }
-
-  void test_parseIfStatement_else_block() {
-    var statement = parseStatement('if (x) {} else {}') as IfStatement;
-    assertNoErrors();
-    expect(statement.ifKeyword, isNotNull);
-    expect(statement.leftParenthesis, isNotNull);
-    expect(statement.condition, isNotNull);
-    expect(statement.rightParenthesis, isNotNull);
-    expect(statement.thenStatement, isNotNull);
-    expect(statement.elseKeyword, isNotNull);
-    expect(statement.elseStatement, isNotNull);
-  }
-
-  void test_parseIfStatement_else_emptyStatements() {
-    var statement = parseStatement('if (true) ; else ;') as IfStatement;
-    assertNoErrors();
-    expect(statement.ifKeyword, isNotNull);
-    expect(statement.leftParenthesis, isNotNull);
-    expect(statement.condition, isNotNull);
-    expect(statement.rightParenthesis, isNotNull);
-    expect(statement.thenStatement, isNotNull);
-    expect(statement.elseKeyword, isNotNull);
-    expect(statement.elseStatement, isNotNull);
-  }
-
-  void test_parseIfStatement_else_statement() {
-    var statement = parseStatement('if (x) f(x); else f(y);') as IfStatement;
-    assertNoErrors();
-    expect(statement.ifKeyword, isNotNull);
-    expect(statement.leftParenthesis, isNotNull);
-    expect(statement.condition, isNotNull);
-    expect(statement.rightParenthesis, isNotNull);
-    expect(statement.thenStatement, isNotNull);
-    expect(statement.elseKeyword, isNotNull);
-    expect(statement.elseStatement, isNotNull);
-  }
-
-  void test_parseIfStatement_noElse_block() {
-    var statement = parseStatement('if (x) {}') as IfStatement;
-    assertNoErrors();
-    expect(statement.ifKeyword, isNotNull);
-    expect(statement.leftParenthesis, isNotNull);
-    expect(statement.condition, isNotNull);
-    expect(statement.rightParenthesis, isNotNull);
-    expect(statement.thenStatement, isNotNull);
-    expect(statement.elseKeyword, isNull);
-    expect(statement.elseStatement, isNull);
-  }
-
-  void test_parseIfStatement_noElse_statement() {
-    var statement = parseStatement('if (x) f(x);') as IfStatement;
-    assertNoErrors();
-    expect(statement.ifKeyword, isNotNull);
-    expect(statement.leftParenthesis, isNotNull);
-    expect(statement.condition, isNotNull);
-    expect(statement.rightParenthesis, isNotNull);
-    expect(statement.thenStatement, isNotNull);
-    expect(statement.elseKeyword, isNull);
-    expect(statement.elseStatement, isNull);
-  }
-
-  void test_parseNonLabeledStatement_const_list_empty() {
-    var statement = parseStatement('const [];') as ExpressionStatement;
-    assertNoErrors();
-    expect(statement.expression, isNotNull);
-  }
-
-  void test_parseNonLabeledStatement_const_list_nonEmpty() {
-    var statement = parseStatement('const [1, 2];') as ExpressionStatement;
-    assertNoErrors();
-    expect(statement.expression, isNotNull);
-  }
-
-  void test_parseNonLabeledStatement_const_map_empty() {
-    var statement = parseStatement('const {};') as ExpressionStatement;
-    assertNoErrors();
-    expect(statement.expression, isNotNull);
-  }
-
-  void test_parseNonLabeledStatement_const_map_nonEmpty() {
-    // TODO(brianwilkerson) Implement more tests for this method.
-    var statement = parseStatement("const {'a' : 1};") as ExpressionStatement;
-    assertNoErrors();
-    expect(statement.expression, isNotNull);
-  }
-
-  void test_parseNonLabeledStatement_const_object() {
-    var statement = parseStatement('const A();') as ExpressionStatement;
-    assertNoErrors();
-    expect(statement.expression, isNotNull);
-  }
-
-  void test_parseNonLabeledStatement_const_object_named_typeParameters() {
-    var statement = parseStatement('const A<B>.c();') as ExpressionStatement;
-    assertNoErrors();
-    expect(statement.expression, isNotNull);
-  }
-
-  void test_parseNonLabeledStatement_const_object_named_typeParameters_34403() {
-    var statement = parseStatement('const A<B>.c<C>();') as ExpressionStatement;
-    assertErrorsWithCodes(
-        [CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_CONSTRUCTOR]);
-    expect(statement.expression, isNotNull);
-  }
-
-  void test_parseNonLabeledStatement_constructorInvocation() {
-    var statement = parseStatement('new C().m();') as ExpressionStatement;
-    assertNoErrors();
-    expect(statement.expression, isNotNull);
-  }
-
-  void test_parseNonLabeledStatement_false() {
-    var statement = parseStatement('false;') as ExpressionStatement;
-    assertNoErrors();
-    expect(statement.expression, isNotNull);
-  }
-
-  void test_parseNonLabeledStatement_functionDeclaration() {
-    var statement = parseStatement('f() {}') as FunctionDeclarationStatement;
-    assertNoErrors();
-    var function = statement.functionDeclaration.functionExpression;
-    expect(function.parameters.parameters, isEmpty);
-    expect(function.body, isNotNull);
-  }
-
-  void test_parseNonLabeledStatement_functionDeclaration_arguments() {
-    var statement =
-        parseStatement('f(void g()) {}') as FunctionDeclarationStatement;
-    assertNoErrors();
-    var function = statement.functionDeclaration.functionExpression;
-    expect(function.parameters.parameters, hasLength(1));
-    expect(function.body, isNotNull);
-  }
-
-  void test_parseNonLabeledStatement_functionExpressionIndex() {
-    var statement = parseStatement('() {}[0] = null;') as ExpressionStatement;
-    assertNoErrors();
-    expect(statement, isNotNull);
-  }
-
-  void test_parseNonLabeledStatement_functionInvocation() {
-    var statement = parseStatement('f();') as ExpressionStatement;
-    assertNoErrors();
-    expect(statement.expression, isNotNull);
-  }
-
-  void test_parseNonLabeledStatement_invokeFunctionExpression() {
-    var statement =
-        parseStatement('(a) {return a + a;} (3);') as ExpressionStatement;
-    assertNoErrors();
-    var invocation = statement.expression as FunctionExpressionInvocation;
-
-    FunctionExpression expression = invocation.function as FunctionExpression;
-    expect(expression.parameters, isNotNull);
-    expect(expression.body, isNotNull);
-    expect(invocation.typeArguments, isNull);
-    expect(invocation.argumentList.arguments, hasLength(1));
-  }
-
-  void test_parseNonLabeledStatement_localFunction_gftReturnType() {
-    var statement = parseStatement('int Function(int) f(String s) => null;')
-        as FunctionDeclarationStatement;
-    assertNoErrors();
-    FunctionDeclaration function = statement.functionDeclaration;
-    expect(function.returnType, isGenericFunctionType);
-  }
-
-  void test_parseNonLabeledStatement_null() {
-    var statement = parseStatement('null;') as ExpressionStatement;
-    assertNoErrors();
-    expect(statement.expression, isNotNull);
-  }
-
-  void test_parseNonLabeledStatement_startingWithBuiltInIdentifier() {
-    var statement = parseStatement('library.getName();') as ExpressionStatement;
-    assertNoErrors();
-    expect(statement.expression, isNotNull);
-  }
-
-  void test_parseNonLabeledStatement_true() {
-    var statement = parseStatement('true;') as ExpressionStatement;
-    assertNoErrors();
-    expect(statement.expression, isNotNull);
-  }
-
-  void test_parseNonLabeledStatement_typeCast() {
-    var statement = parseStatement('double.NAN as num;') as ExpressionStatement;
-    assertNoErrors();
-    expect(statement.expression, isNotNull);
-  }
-
-  void test_parseNonLabeledStatement_variableDeclaration_final_namedFunction() {
-    var statement = parseStatement('final int Function = 0;')
-        as VariableDeclarationStatement;
-    assertNoErrors();
-    List<VariableDeclaration> variables = statement.variables.variables;
-    expect(variables, hasLength(1));
-    expect(variables[0].name.name, 'Function');
-  }
-
-  void test_parseNonLabeledStatement_variableDeclaration_gftType() {
-    var statement =
-        parseStatement('int Function(int) v;') as VariableDeclarationStatement;
-    assertNoErrors();
-    VariableDeclarationList variableList = statement.variables;
-    List<VariableDeclaration> variables = variableList.variables;
-    expect(variables, hasLength(1));
-    expect(variables[0].name.name, 'v');
-    expect(variableList.type, isGenericFunctionType);
-  }
-
-  void
-      test_parseNonLabeledStatement_variableDeclaration_gftType_functionReturnType() {
-    var statement = parseStatement(
-            'Function Function(int x1, {Function x}) Function<B extends core.int>(int x) v;')
-        as VariableDeclarationStatement;
-    assertNoErrors();
-    VariableDeclarationList variableList = statement.variables;
-    List<VariableDeclaration> variables = variableList.variables;
-    expect(variables, hasLength(1));
-    expect(variables[0].name.name, 'v');
-    expect(variableList.type, isGenericFunctionType);
-  }
-
-  void
-      test_parseNonLabeledStatement_variableDeclaration_gftType_gftReturnType() {
-    var statement = parseStatement('Function(int) Function(int) v;')
-        as VariableDeclarationStatement;
-    assertNoErrors();
-    VariableDeclarationList variableList = statement.variables;
-    List<VariableDeclaration> variables = variableList.variables;
-    expect(variables, hasLength(1));
-    expect(variables[0].name.name, 'v');
-    expect(variableList.type, isGenericFunctionType);
-  }
-
-  void
-      test_parseNonLabeledStatement_variableDeclaration_gftType_gftReturnType2() {
-    var statement = parseStatement('int Function(int) Function(int) v;')
-        as VariableDeclarationStatement;
-    assertNoErrors();
-    VariableDeclarationList variableList = statement.variables;
-    List<VariableDeclaration> variables = variableList.variables;
-    expect(variables, hasLength(1));
-    expect(variables[0].name.name, 'v');
-    expect(variableList.type, isGenericFunctionType);
-  }
-
-  void
-      test_parseNonLabeledStatement_variableDeclaration_gftType_noReturnType() {
-    var statement =
-        parseStatement('Function(int) v;') as VariableDeclarationStatement;
-    assertNoErrors();
-    VariableDeclarationList variableList = statement.variables;
-    List<VariableDeclaration> variables = variableList.variables;
-    expect(variables, hasLength(1));
-    expect(variables[0].name.name, 'v');
-    expect(variableList.type, isGenericFunctionType);
-  }
-
-  void test_parseNonLabeledStatement_variableDeclaration_gftType_returnType() {
-    var statement =
-        parseStatement('int Function<T>() v;') as VariableDeclarationStatement;
-    assertNoErrors();
-    VariableDeclarationList variableList = statement.variables;
-    List<VariableDeclaration> variables = variableList.variables;
-    expect(variables, hasLength(1));
-    expect(variables[0].name.name, 'v');
-    expect(variableList.type, isGenericFunctionType);
-  }
-
-  void
-      test_parseNonLabeledStatement_variableDeclaration_gftType_voidReturnType() {
-    var statement =
-        parseStatement('void Function() v;') as VariableDeclarationStatement;
-    assertNoErrors();
-    VariableDeclarationList variableList = statement.variables;
-    List<VariableDeclaration> variables = variableList.variables;
-    expect(variables, hasLength(1));
-    expect(variables[0].name.name, 'v');
-    expect(variableList.type, isGenericFunctionType);
-  }
-
-  void test_parseNonLabeledStatement_variableDeclaration_typeParam() {
-    VariableDeclarationStatement statement = parseStatement('C<T> v;');
-    assertNoErrors();
-    VariableDeclarationList variableList = statement.variables;
-    List<VariableDeclaration> variables = variableList.variables;
-    expect(variables, hasLength(1));
-    expect(variables[0].name.name, 'v');
-    TypeName typeName = variableList.type;
-    expect(typeName.name.name, 'C');
-    expect(typeName.typeArguments.arguments, hasLength(1));
-    TypeName typeArgument = typeName.typeArguments.arguments[0];
-    expect(typeArgument.name.name, 'T');
-  }
-
-  void test_parseNonLabeledStatement_variableDeclaration_typeParam2() {
-    VariableDeclarationStatement statement =
-        parseStatement('C<T /* ignored comment */ > v;');
-    assertNoErrors();
-    VariableDeclarationList variableList = statement.variables;
-    List<VariableDeclaration> variables = variableList.variables;
-    expect(variables, hasLength(1));
-    expect(variables[0].name.name, 'v');
-    TypeName typeName = variableList.type;
-    expect(typeName.name.name, 'C');
-    expect(typeName.typeArguments.arguments, hasLength(1));
-    TypeName typeArgument = typeName.typeArguments.arguments[0];
-    expect(typeArgument.name.name, 'T');
-  }
-
-  void test_parseNonLabeledStatement_variableDeclaration_typeParam3() {
-    VariableDeclarationStatement statement =
-        parseStatement('C<T Function(String s)> v;');
-    assertNoErrors();
-    VariableDeclarationList variableList = statement.variables;
-    List<VariableDeclaration> variables = variableList.variables;
-    expect(variables, hasLength(1));
-    expect(variables[0].name.name, 'v');
-    TypeName typeName = variableList.type;
-    expect(typeName.name.name, 'C');
-    expect(typeName.typeArguments.arguments, hasLength(1));
-    expect(typeName.typeArguments.arguments[0], isGenericFunctionType);
-  }
-
-  void test_parseStatement_emptyTypeArgumentList() {
-    var declaration = parseStatement('C<> c;') as VariableDeclarationStatement;
-    assertErrorsWithCodes([ParserErrorCode.EXPECTED_TYPE_NAME]);
-    VariableDeclarationList variables = declaration.variables;
-    TypeName type = variables.type;
-    TypeArgumentList argumentList = type.typeArguments;
-    expect(argumentList.leftBracket, isNotNull);
-    expect(argumentList.arguments, hasLength(1));
-    expect(argumentList.arguments[0].isSynthetic, isTrue);
-    expect(argumentList.rightBracket, isNotNull);
-  }
-
-  void test_parseStatement_function_gftReturnType() {
-    var statement =
-        parseStatement('void Function<A>(core.List<core.int> x) m() => null;')
-            as FunctionDeclarationStatement;
-    expect(statement.functionDeclaration.functionExpression.body,
-        isExpressionFunctionBody);
-  }
-
-  void test_parseStatement_functionDeclaration_noReturnType() {
-    var statement = parseStatement('true;') as ExpressionStatement;
-    assertNoErrors();
-    expect(statement.expression, isNotNull);
-  }
-
-  void test_parseStatement_functionDeclaration_noReturnType_typeParameters() {
-    var statement =
-        parseStatement('f<E>(a, b) {}') as FunctionDeclarationStatement;
-    assertNoErrors();
-    expect(statement.functionDeclaration, isNotNull);
-  }
-
-  void test_parseStatement_functionDeclaration_returnType() {
-    // TODO(brianwilkerson) Implement more tests for this method.
-    var statement =
-        parseStatement('int f(a, b) {}') as FunctionDeclarationStatement;
-    assertNoErrors();
-    expect(statement.functionDeclaration, isNotNull);
-  }
-
-  void test_parseStatement_functionDeclaration_returnType_typeParameters() {
-    var statement =
-        parseStatement('int f<E>(a, b) {}') as FunctionDeclarationStatement;
-    assertNoErrors();
-    expect(statement.functionDeclaration, isNotNull);
-  }
-
-  void test_parseStatement_multipleLabels() {
-    var statement = parseStatement('l: m: return x;') as LabeledStatement;
-    expect(statement.labels, hasLength(2));
-    expect(statement.statement, isNotNull);
-  }
-
-  void test_parseStatement_noLabels() {
-    var statement = parseStatement('return x;') as ReturnStatement;
-    assertNoErrors();
-    expect(statement, isNotNull);
-  }
-
-  void test_parseStatement_singleLabel() {
-    var statement = parseStatement('l: return x;') as LabeledStatement;
-    assertNoErrors();
-    expect(statement.labels, hasLength(1));
-    expect(statement.labels[0].label.inDeclarationContext(), isTrue);
-    expect(statement.statement, isNotNull);
-  }
-
-  void test_parseSwitchStatement_case() {
-    var statement =
-        parseStatement('switch (a) {case 1: return "I";}') as SwitchStatement;
-    assertNoErrors();
-    expect(statement.switchKeyword, isNotNull);
-    expect(statement.leftParenthesis, isNotNull);
-    expect(statement.expression, isNotNull);
-    expect(statement.rightParenthesis, isNotNull);
-    expect(statement.leftBracket, isNotNull);
-    expect(statement.members, hasLength(1));
-    expect(statement.rightBracket, isNotNull);
-  }
-
-  void test_parseSwitchStatement_empty() {
-    var statement = parseStatement('switch (a) {}') as SwitchStatement;
-    assertNoErrors();
-    expect(statement.switchKeyword, isNotNull);
-    expect(statement.leftParenthesis, isNotNull);
-    expect(statement.expression, isNotNull);
-    expect(statement.rightParenthesis, isNotNull);
-    expect(statement.leftBracket, isNotNull);
-    expect(statement.members, hasLength(0));
-    expect(statement.rightBracket, isNotNull);
-  }
-
-  void test_parseSwitchStatement_labeledCase() {
-    var statement =
-        parseStatement('switch (a) {l1: l2: l3: case(1):}') as SwitchStatement;
-    assertNoErrors();
-    expect(statement.switchKeyword, isNotNull);
-    expect(statement.leftParenthesis, isNotNull);
-    expect(statement.expression, isNotNull);
-    expect(statement.rightParenthesis, isNotNull);
-    expect(statement.leftBracket, isNotNull);
-    expect(statement.members, hasLength(1));
-    {
-      List<Label> labels = statement.members[0].labels;
-      expect(labels, hasLength(3));
-      expect(labels[0].label.inDeclarationContext(), isTrue);
-      expect(labels[1].label.inDeclarationContext(), isTrue);
-      expect(labels[2].label.inDeclarationContext(), isTrue);
-    }
-    expect(statement.rightBracket, isNotNull);
-  }
-
-  void test_parseSwitchStatement_labeledCase2() {
-    SwitchStatement statement =
-        parseStatement('switch (a) {l1: case 0: l2: case 1: return;}');
-    assertNoErrors();
-    expect(statement.switchKeyword, isNotNull);
-    expect(statement.leftParenthesis, isNotNull);
-    expect(statement.expression, isNotNull);
-    expect(statement.rightParenthesis, isNotNull);
-    expect(statement.leftBracket, isNotNull);
-    expect(statement.members, hasLength(2));
-    {
-      List<Label> labels = statement.members[0].labels;
-      expect(labels, hasLength(1));
-      expect(labels[0].label.inDeclarationContext(), isTrue);
-    }
-    {
-      List<Label> labels = statement.members[1].labels;
-      expect(labels, hasLength(1));
-      expect(labels[0].label.inDeclarationContext(), isTrue);
-    }
-    expect(statement.rightBracket, isNotNull);
-  }
-
-  void test_parseSwitchStatement_labeledDefault() {
-    var statement =
-        parseStatement('switch (a) {l1: l2: l3: default:}') as SwitchStatement;
-    assertNoErrors();
-    expect(statement.switchKeyword, isNotNull);
-    expect(statement.leftParenthesis, isNotNull);
-    expect(statement.expression, isNotNull);
-    expect(statement.rightParenthesis, isNotNull);
-    expect(statement.leftBracket, isNotNull);
-    expect(statement.members, hasLength(1));
-    {
-      List<Label> labels = statement.members[0].labels;
-      expect(labels, hasLength(3));
-      expect(labels[0].label.inDeclarationContext(), isTrue);
-      expect(labels[1].label.inDeclarationContext(), isTrue);
-      expect(labels[2].label.inDeclarationContext(), isTrue);
-    }
-    expect(statement.rightBracket, isNotNull);
-  }
-
-  void test_parseSwitchStatement_labeledDefault2() {
-    SwitchStatement statement =
-        parseStatement('switch (a) {l1: case 0: l2: default: return;}');
-    assertNoErrors();
-    expect(statement.switchKeyword, isNotNull);
-    expect(statement.leftParenthesis, isNotNull);
-    expect(statement.expression, isNotNull);
-    expect(statement.rightParenthesis, isNotNull);
-    expect(statement.leftBracket, isNotNull);
-    expect(statement.members, hasLength(2));
-    {
-      List<Label> labels = statement.members[0].labels;
-      expect(labels, hasLength(1));
-      expect(labels[0].label.inDeclarationContext(), isTrue);
-    }
-    {
-      List<Label> labels = statement.members[1].labels;
-      expect(labels, hasLength(1));
-      expect(labels[0].label.inDeclarationContext(), isTrue);
-    }
-    expect(statement.rightBracket, isNotNull);
-  }
-
-  void test_parseSwitchStatement_labeledStatementInCase() {
-    var statement = parseStatement('switch (a) {case 0: f(); l1: g(); break;}')
-        as SwitchStatement;
-    assertNoErrors();
-    expect(statement.switchKeyword, isNotNull);
-    expect(statement.leftParenthesis, isNotNull);
-    expect(statement.expression, isNotNull);
-    expect(statement.rightParenthesis, isNotNull);
-    expect(statement.leftBracket, isNotNull);
-    expect(statement.members, hasLength(1));
-    expect(statement.members[0].statements, hasLength(3));
-    expect(statement.rightBracket, isNotNull);
-  }
-
-  void test_parseTryStatement_catch() {
-    var statement = parseStatement('try {} catch (e) {}') as TryStatement;
-    assertNoErrors();
-    expect(statement.tryKeyword, isNotNull);
-    expect(statement.body, isNotNull);
-    NodeList<CatchClause> catchClauses = statement.catchClauses;
-    expect(catchClauses, hasLength(1));
-    CatchClause clause = catchClauses[0];
-    expect(clause.onKeyword, isNull);
-    expect(clause.exceptionType, isNull);
-    expect(clause.catchKeyword, isNotNull);
-    expect(clause.exceptionParameter, isNotNull);
-    expect(clause.comma, isNull);
-    expect(clause.stackTraceParameter, isNull);
-    expect(clause.body, isNotNull);
-    expect(statement.finallyKeyword, isNull);
-    expect(statement.finallyBlock, isNull);
-  }
-
-  void test_parseTryStatement_catch_error_invalidCatchParam() {
-    CompilationUnit unit = parseCompilationUnit(
-        'main() { try {} catch (int e) { } }',
-        errors: [expectedError(ParserErrorCode.CATCH_SYNTAX, 27, 1)]);
-    FunctionDeclaration method = unit.declarations[0];
-    BlockFunctionBody body = method.functionExpression.body;
-    TryStatement statement = body.block.statements[0];
-    expect(statement.tryKeyword, isNotNull);
-    expect(statement.body, isNotNull);
-    NodeList<CatchClause> catchClauses = statement.catchClauses;
-    expect(catchClauses, hasLength(1));
-    CatchClause clause = catchClauses[0];
-    expect(clause.onKeyword, isNull);
-    expect(clause.exceptionType, isNull);
-    expect(clause.catchKeyword, isNotNull);
-    expect(clause.exceptionParameter.name, 'int');
-    expect(clause.comma, isNotNull);
-    expect(clause.stackTraceParameter.name, 'e');
-    expect(clause.body, isNotNull);
-    expect(statement.finallyKeyword, isNull);
-    expect(statement.finallyBlock, isNull);
-  }
-
-  void test_parseTryStatement_catch_error_missingCatchParam() {
-    var statement = parseStatement('try {} catch () {}') as TryStatement;
-    listener.assertErrors([expectedError(ParserErrorCode.CATCH_SYNTAX, 14, 1)]);
-    expect(statement.tryKeyword, isNotNull);
-    expect(statement.body, isNotNull);
-    NodeList<CatchClause> catchClauses = statement.catchClauses;
-    expect(catchClauses, hasLength(1));
-    CatchClause clause = catchClauses[0];
-    expect(clause.onKeyword, isNull);
-    expect(clause.exceptionType, isNull);
-    expect(clause.catchKeyword, isNotNull);
-    expect(clause.exceptionParameter, isNotNull);
-    expect(clause.comma, isNull);
-    expect(clause.stackTraceParameter, isNull);
-    expect(clause.body, isNotNull);
-    expect(statement.finallyKeyword, isNull);
-    expect(statement.finallyBlock, isNull);
-  }
-
-  void test_parseTryStatement_catch_error_missingCatchParen() {
-    var statement = parseStatement('try {} catch {}') as TryStatement;
-    listener.assertErrors([expectedError(ParserErrorCode.CATCH_SYNTAX, 13, 1)]);
-    expect(statement.tryKeyword, isNotNull);
-    expect(statement.body, isNotNull);
-    NodeList<CatchClause> catchClauses = statement.catchClauses;
-    expect(catchClauses, hasLength(1));
-    CatchClause clause = catchClauses[0];
-    expect(clause.onKeyword, isNull);
-    expect(clause.exceptionType, isNull);
-    expect(clause.catchKeyword, isNotNull);
-    expect(clause.exceptionParameter, isNotNull);
-    expect(clause.comma, isNull);
-    expect(clause.stackTraceParameter, isNull);
-    expect(clause.body, isNotNull);
-    expect(statement.finallyKeyword, isNull);
-    expect(statement.finallyBlock, isNull);
-  }
-
-  void test_parseTryStatement_catch_error_missingCatchTrace() {
-    var statement = parseStatement('try {} catch (e,) {}') as TryStatement;
-    listener.assertErrors([expectedError(ParserErrorCode.CATCH_SYNTAX, 16, 1)]);
-    expect(statement.tryKeyword, isNotNull);
-    expect(statement.body, isNotNull);
-    NodeList<CatchClause> catchClauses = statement.catchClauses;
-    expect(catchClauses, hasLength(1));
-    CatchClause clause = catchClauses[0];
-    expect(clause.onKeyword, isNull);
-    expect(clause.exceptionType, isNull);
-    expect(clause.catchKeyword, isNotNull);
-    expect(clause.exceptionParameter, isNotNull);
-    expect(clause.comma, isNotNull);
-    expect(clause.stackTraceParameter, isNotNull);
-    expect(clause.body, isNotNull);
-    expect(statement.finallyKeyword, isNull);
-    expect(statement.finallyBlock, isNull);
-  }
-
-  void test_parseTryStatement_catch_finally() {
-    var statement =
-        parseStatement('try {} catch (e, s) {} finally {}') as TryStatement;
-    assertNoErrors();
-    expect(statement.tryKeyword, isNotNull);
-    expect(statement.body, isNotNull);
-    NodeList<CatchClause> catchClauses = statement.catchClauses;
-    expect(catchClauses, hasLength(1));
-    CatchClause clause = catchClauses[0];
-    expect(clause.onKeyword, isNull);
-    expect(clause.exceptionType, isNull);
-    expect(clause.catchKeyword, isNotNull);
-    expect(clause.exceptionParameter, isNotNull);
-    expect(clause.comma, isNotNull);
-    expect(clause.stackTraceParameter, isNotNull);
-    expect(clause.body, isNotNull);
-    expect(statement.finallyKeyword, isNotNull);
-    expect(statement.finallyBlock, isNotNull);
-  }
-
-  void test_parseTryStatement_finally() {
-    var statement = parseStatement('try {} finally {}') as TryStatement;
-    assertNoErrors();
-    expect(statement.tryKeyword, isNotNull);
-    expect(statement.body, isNotNull);
-    expect(statement.catchClauses, hasLength(0));
-    expect(statement.finallyKeyword, isNotNull);
-    expect(statement.finallyBlock, isNotNull);
-  }
-
-  void test_parseTryStatement_multiple() {
-    var statement =
-        parseStatement('try {} on NPE catch (e) {} on Error {} catch (e) {}')
-            as TryStatement;
-    assertNoErrors();
-    expect(statement.tryKeyword, isNotNull);
-    expect(statement.body, isNotNull);
-    expect(statement.catchClauses, hasLength(3));
-    expect(statement.finallyKeyword, isNull);
-    expect(statement.finallyBlock, isNull);
-  }
-
-  void test_parseTryStatement_on() {
-    var statement = parseStatement('try {} on Error {}') as TryStatement;
-    assertNoErrors();
-    expect(statement.tryKeyword, isNotNull);
-    expect(statement.body, isNotNull);
-    NodeList<CatchClause> catchClauses = statement.catchClauses;
-    expect(catchClauses, hasLength(1));
-    CatchClause clause = catchClauses[0];
-    expect(clause.onKeyword, isNotNull);
-    expect(clause.exceptionType, isNotNull);
-    expect(clause.catchKeyword, isNull);
-    expect(clause.exceptionParameter, isNull);
-    expect(clause.comma, isNull);
-    expect(clause.stackTraceParameter, isNull);
-    expect(clause.body, isNotNull);
-    expect(statement.finallyKeyword, isNull);
-    expect(statement.finallyBlock, isNull);
-  }
-
-  void test_parseTryStatement_on_catch() {
-    var statement =
-        parseStatement('try {} on Error catch (e, s) {}') as TryStatement;
-    assertNoErrors();
-    expect(statement.tryKeyword, isNotNull);
-    expect(statement.body, isNotNull);
-    NodeList<CatchClause> catchClauses = statement.catchClauses;
-    expect(catchClauses, hasLength(1));
-    CatchClause clause = catchClauses[0];
-    expect(clause.onKeyword, isNotNull);
-    expect(clause.exceptionType, isNotNull);
-    expect(clause.catchKeyword, isNotNull);
-    expect(clause.exceptionParameter, isNotNull);
-    expect(clause.comma, isNotNull);
-    expect(clause.stackTraceParameter, isNotNull);
-    expect(clause.body, isNotNull);
-    expect(statement.finallyKeyword, isNull);
-    expect(statement.finallyBlock, isNull);
-  }
-
-  void test_parseTryStatement_on_catch_finally() {
-    var statement = parseStatement('try {} on Error catch (e, s) {} finally {}')
-        as TryStatement;
-    assertNoErrors();
-    expect(statement.tryKeyword, isNotNull);
-    expect(statement.body, isNotNull);
-    NodeList<CatchClause> catchClauses = statement.catchClauses;
-    expect(catchClauses, hasLength(1));
-    CatchClause clause = catchClauses[0];
-    expect(clause.onKeyword, isNotNull);
-    expect(clause.exceptionType, isNotNull);
-    expect(clause.catchKeyword, isNotNull);
-    expect(clause.exceptionParameter, isNotNull);
-    expect(clause.comma, isNotNull);
-    expect(clause.stackTraceParameter, isNotNull);
-    expect(clause.body, isNotNull);
-    expect(statement.finallyKeyword, isNotNull);
-    expect(statement.finallyBlock, isNotNull);
-  }
-
-  void test_parseVariableDeclaration_equals_builtIn() {
-    VariableDeclarationStatement statement = parseStatement('int set = 0;');
-    assertNoErrors();
-    expect(statement.semicolon, isNotNull);
-    VariableDeclarationList variableList = statement.variables;
-    expect(variableList, isNotNull);
-    expect(variableList.variables, hasLength(1));
-  }
-
-  void test_parseVariableDeclarationListAfterMetadata_const_noType() {
-    var declarationList = parseVariableDeclarationList('const a = 0');
-    assertNoErrors();
-    expect(declarationList.keyword.lexeme, 'const');
-    expect(declarationList.type, isNull);
-    expect(declarationList.variables, hasLength(1));
-  }
-
-  void test_parseVariableDeclarationListAfterMetadata_const_type() {
-    var declarationList = parseVariableDeclarationList('const A a');
-    assertNoErrors();
-    expect(declarationList.keyword.lexeme, 'const');
-    expect(declarationList.type, isNotNull);
-    expect(declarationList.variables, hasLength(1));
-  }
-
-  void test_parseVariableDeclarationListAfterMetadata_final_noType() {
-    var declarationList = parseVariableDeclarationList('final a');
-    assertNoErrors();
-    expect(declarationList.keyword, isNotNull);
-    expect(declarationList.type, isNull);
-    expect(declarationList.variables, hasLength(1));
-  }
-
-  void test_parseVariableDeclarationListAfterMetadata_final_type() {
-    var declarationList = parseVariableDeclarationList('final A a');
-    assertNoErrors();
-    expect(declarationList.keyword.lexeme, 'final');
-    expect(declarationList.type, isNotNull);
-    expect(declarationList.variables, hasLength(1));
-  }
-
-  void test_parseVariableDeclarationListAfterMetadata_type_multiple() {
-    var declarationList = parseVariableDeclarationList('A a, b, c');
-    assertNoErrors();
-    expect(declarationList.keyword, isNull);
-    expect(declarationList.type, isNotNull);
-    expect(declarationList.variables, hasLength(3));
-  }
-
-  void test_parseVariableDeclarationListAfterMetadata_type_single() {
-    var declarationList = parseVariableDeclarationList('A a');
-    assertNoErrors();
-    expect(declarationList.keyword, isNull);
-    expect(declarationList.type, isNotNull);
-    expect(declarationList.variables, hasLength(1));
-  }
-
-  void test_parseVariableDeclarationListAfterMetadata_var_multiple() {
-    var declarationList = parseVariableDeclarationList('var a, b, c');
-    assertNoErrors();
-    expect(declarationList.keyword.lexeme, 'var');
-    expect(declarationList.type, isNull);
-    expect(declarationList.variables, hasLength(3));
-  }
-
-  void test_parseVariableDeclarationListAfterMetadata_var_single() {
-    var declarationList = parseVariableDeclarationList('var a');
-    assertNoErrors();
-    expect(declarationList.keyword.lexeme, 'var');
-    expect(declarationList.type, isNull);
-    expect(declarationList.variables, hasLength(1));
-  }
-
-  void test_parseVariableDeclarationStatementAfterMetadata_multiple() {
-    var statement =
-        parseStatement('var x, y, z;') as VariableDeclarationStatement;
-    assertNoErrors();
-    expect(statement.semicolon, isNotNull);
-    VariableDeclarationList variableList = statement.variables;
-    expect(variableList, isNotNull);
-    expect(variableList.variables, hasLength(3));
-  }
-
-  void test_parseVariableDeclarationStatementAfterMetadata_single() {
-    var statement = parseStatement('var x;') as VariableDeclarationStatement;
-    assertNoErrors();
-    expect(statement.semicolon, isNotNull);
-    VariableDeclarationList variableList = statement.variables;
-    expect(variableList, isNotNull);
-    expect(variableList.variables, hasLength(1));
-  }
-
-  void test_parseWhileStatement() {
-    var statement = parseStatement('while (x) {}') as WhileStatement;
-    assertNoErrors();
-    expect(statement.whileKeyword, isNotNull);
-    expect(statement.leftParenthesis, isNotNull);
-    expect(statement.condition, isNotNull);
-    expect(statement.rightParenthesis, isNotNull);
-    expect(statement.body, isNotNull);
-  }
-
-  void test_parseYieldStatement_each() {
-    var statement =
-        _parseAsyncStatement('yield* x;', isGenerator: true) as YieldStatement;
-    assertNoErrors();
-    expect(statement.yieldKeyword, isNotNull);
-    expect(statement.star, isNotNull);
-    expect(statement.expression, isNotNull);
-    expect(statement.semicolon, isNotNull);
-  }
-
-  void test_parseYieldStatement_normal() {
-    var statement =
-        _parseAsyncStatement('yield x;', isGenerator: true) as YieldStatement;
-    assertNoErrors();
-    expect(statement.yieldKeyword, isNotNull);
-    expect(statement.star, isNull);
-    expect(statement.expression, isNotNull);
-    expect(statement.semicolon, isNotNull);
-  }
-
-  Statement _parseAsyncStatement(String code, {bool isGenerator = false}) {
-    var star = isGenerator ? '*' : '';
-    var localFunction = parseStatement('wrapper() async$star { $code }')
-        as FunctionDeclarationStatement;
-    var localBody = localFunction.functionDeclaration.functionExpression.body
-        as BlockFunctionBody;
-    return localBody.block.statements.single;
-  }
-}
-
-/// Tests which exercise the parser using a complete compilation unit or
-/// compilation unit member.
-mixin TopLevelParserTestMixin implements AbstractParserTestCase {
-  void test_function_literal_allowed_at_toplevel() {
-    parseCompilationUnit("var x = () {};");
-  }
-
-  void
-      test_function_literal_allowed_in_ArgumentList_in_ConstructorFieldInitializer() {
-    parseCompilationUnit("class C { C() : a = f(() {}); }");
-  }
-
-  void
-      test_function_literal_allowed_in_IndexExpression_in_ConstructorFieldInitializer() {
-    parseCompilationUnit("class C { C() : a = x[() {}]; }");
-  }
-
-  void
-      test_function_literal_allowed_in_ListLiteral_in_ConstructorFieldInitializer() {
-    parseCompilationUnit("class C { C() : a = [() {}]; }");
-  }
-
-  void
-      test_function_literal_allowed_in_MapLiteral_in_ConstructorFieldInitializer() {
-    parseCompilationUnit("class C { C() : a = {'key': () {}}; }");
-  }
-
-  void
-      test_function_literal_allowed_in_ParenthesizedExpression_in_ConstructorFieldInitializer() {
-    parseCompilationUnit("class C { C() : a = (() {}); }");
-  }
-
-  void
-      test_function_literal_allowed_in_StringInterpolation_in_ConstructorFieldInitializer() {
-    parseCompilationUnit("class C { C() : a = \"\${(){}}\"; }");
-  }
-
-  void test_import_as_show() {
-    parseCompilationUnit("import 'dart:math' as M show E;");
-  }
-
-  void test_import_show_hide() {
-    parseCompilationUnit(
-        "import 'import1_lib.dart' show hide, show hide ugly;");
-  }
-
-  void test_import_withDocComment() {
-    var compilationUnit = parseCompilationUnit('/// Doc\nimport "foo.dart";');
-    var importDirective = compilationUnit.directives[0];
-    expectCommentText(importDirective.documentationComment, '/// Doc');
-  }
-
-  void test_parseClassDeclaration_abstract() {
-    createParser('abstract class A {}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isClassDeclaration);
-    ClassDeclaration declaration = member;
-    expect(declaration.documentationComment, isNull);
-    expect(declaration.abstractKeyword, isNotNull);
-    expect(declaration.extendsClause, isNull);
-    expect(declaration.implementsClause, isNull);
-    expect(declaration.classKeyword, isNotNull);
-    expect(declaration.leftBracket, isNotNull);
-    expect(declaration.name, isNotNull);
-    expect(declaration.members, hasLength(0));
-    expect(declaration.rightBracket, isNotNull);
-    expect(declaration.typeParameters, isNull);
-  }
-
-  void test_parseClassDeclaration_empty() {
-    createParser('class A {}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isClassDeclaration);
-    ClassDeclaration declaration = member;
-    expect(declaration.documentationComment, isNull);
-    expect(declaration.abstractKeyword, isNull);
-    expect(declaration.extendsClause, isNull);
-    expect(declaration.implementsClause, isNull);
-    expect(declaration.classKeyword, isNotNull);
-    expect(declaration.leftBracket, isNotNull);
-    expect(declaration.name, isNotNull);
-    _assertIsDeclarationName(declaration.name);
-    expect(declaration.members, hasLength(0));
-    expect(declaration.rightBracket, isNotNull);
-    expect(declaration.typeParameters, isNull);
-  }
-
-  void test_parseClassDeclaration_extends() {
-    createParser('class A extends B {}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isClassDeclaration);
-    ClassDeclaration declaration = member;
-    expect(declaration.documentationComment, isNull);
-    expect(declaration.abstractKeyword, isNull);
-    expect(declaration.extendsClause, isNotNull);
-    expect(declaration.implementsClause, isNull);
-    expect(declaration.classKeyword, isNotNull);
-    expect(declaration.leftBracket, isNotNull);
-    expect(declaration.name, isNotNull);
-    expect(declaration.members, hasLength(0));
-    expect(declaration.rightBracket, isNotNull);
-    expect(declaration.typeParameters, isNull);
-  }
-
-  void test_parseClassDeclaration_extendsAndImplements() {
-    createParser('class A extends B implements C {}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isClassDeclaration);
-    ClassDeclaration declaration = member;
-    expect(declaration.documentationComment, isNull);
-    expect(declaration.abstractKeyword, isNull);
-    expect(declaration.extendsClause, isNotNull);
-    expect(declaration.implementsClause, isNotNull);
-    expect(declaration.classKeyword, isNotNull);
-    expect(declaration.leftBracket, isNotNull);
-    expect(declaration.name, isNotNull);
-    expect(declaration.members, hasLength(0));
-    expect(declaration.rightBracket, isNotNull);
-    expect(declaration.typeParameters, isNull);
-  }
-
-  void test_parseClassDeclaration_extendsAndWith() {
-    createParser('class A extends B with C {}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isClassDeclaration);
-    ClassDeclaration declaration = member;
-    expect(declaration.documentationComment, isNull);
-    expect(declaration.abstractKeyword, isNull);
-    expect(declaration.classKeyword, isNotNull);
-    expect(declaration.name, isNotNull);
-    expect(declaration.typeParameters, isNull);
-    expect(declaration.extendsClause, isNotNull);
-    expect(declaration.withClause, isNotNull);
-    expect(declaration.implementsClause, isNull);
-    expect(declaration.leftBracket, isNotNull);
-    expect(declaration.members, hasLength(0));
-    expect(declaration.rightBracket, isNotNull);
-  }
-
-  void test_parseClassDeclaration_extendsAndWithAndImplements() {
-    createParser('class A extends B with C implements D {}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isClassDeclaration);
-    ClassDeclaration declaration = member;
-    expect(declaration.documentationComment, isNull);
-    expect(declaration.abstractKeyword, isNull);
-    expect(declaration.classKeyword, isNotNull);
-    expect(declaration.name, isNotNull);
-    expect(declaration.typeParameters, isNull);
-    expect(declaration.extendsClause, isNotNull);
-    expect(declaration.withClause, isNotNull);
-    expect(declaration.implementsClause, isNotNull);
-    expect(declaration.leftBracket, isNotNull);
-    expect(declaration.members, hasLength(0));
-    expect(declaration.rightBracket, isNotNull);
-  }
-
-  void test_parseClassDeclaration_implements() {
-    createParser('class A implements C {}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isClassDeclaration);
-    ClassDeclaration declaration = member;
-    expect(declaration.documentationComment, isNull);
-    expect(declaration.abstractKeyword, isNull);
-    expect(declaration.extendsClause, isNull);
-    expect(declaration.implementsClause, isNotNull);
-    expect(declaration.classKeyword, isNotNull);
-    expect(declaration.leftBracket, isNotNull);
-    expect(declaration.name, isNotNull);
-    expect(declaration.members, hasLength(0));
-    expect(declaration.rightBracket, isNotNull);
-    expect(declaration.typeParameters, isNull);
-  }
-
-  void test_parseClassDeclaration_metadata() {
-    createParser('@A @B(2) @C.foo(3) @d.E.bar(4, 5) class X {}');
-    var declaration = parseFullCompilationUnitMember() as ClassDeclaration;
-    expect(declaration.metadata, hasLength(4));
-
-    {
-      var annotation = declaration.metadata[0];
-      expect(annotation.atSign, isNotNull);
-      expect(annotation.name, isSimpleIdentifier);
-      expect(annotation.name.name, 'A');
-      expect(annotation.period, isNull);
-      expect(annotation.constructorName, isNull);
-      expect(annotation.arguments, isNull);
-    }
-
-    {
-      var annotation = declaration.metadata[1];
-      expect(annotation.atSign, isNotNull);
-      expect(annotation.name, isSimpleIdentifier);
-      expect(annotation.name.name, 'B');
-      expect(annotation.period, isNull);
-      expect(annotation.constructorName, isNull);
-      expect(annotation.arguments, isNotNull);
-      expect(annotation.arguments.arguments, hasLength(1));
-    }
-
-    {
-      var annotation = declaration.metadata[2];
-      expect(annotation.atSign, isNotNull);
-      expect(annotation.name, isPrefixedIdentifier);
-      expect(annotation.name.name, 'C.foo');
-      expect(annotation.period, isNull);
-      expect(annotation.constructorName, isNull);
-      expect(annotation.arguments, isNotNull);
-      expect(annotation.arguments.arguments, hasLength(1));
-    }
-
-    {
-      var annotation = declaration.metadata[3];
-      expect(annotation.atSign, isNotNull);
-      expect(annotation.name, isPrefixedIdentifier);
-      expect(annotation.name.name, 'd.E');
-      expect(annotation.period, isNotNull);
-      expect(annotation.constructorName, isNotNull);
-      expect(annotation.constructorName.name, 'bar');
-      expect(annotation.arguments, isNotNull);
-      expect(annotation.arguments.arguments, hasLength(2));
-    }
-  }
-
-  void test_parseClassDeclaration_native() {
-    createParser('class A native "nativeValue" {}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    if (!allowNativeClause) {
-      assertErrorsWithCodes([
-        ParserErrorCode.NATIVE_CLAUSE_SHOULD_BE_ANNOTATION,
-      ]);
-    } else {
-      assertNoErrors();
-    }
-    expect(member, isClassDeclaration);
-    ClassDeclaration declaration = member;
-    NativeClause nativeClause = declaration.nativeClause;
-    expect(nativeClause, isNotNull);
-    expect(nativeClause.nativeKeyword, isNotNull);
-    expect(nativeClause.name.stringValue, "nativeValue");
-    expect(nativeClause.beginToken, same(nativeClause.nativeKeyword));
-    expect(nativeClause.endToken, same(nativeClause.name.endToken));
-  }
-
-  void test_parseClassDeclaration_nonEmpty() {
-    createParser('class A {var f;}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isClassDeclaration);
-    ClassDeclaration declaration = member;
-    expect(declaration.documentationComment, isNull);
-    expect(declaration.abstractKeyword, isNull);
-    expect(declaration.extendsClause, isNull);
-    expect(declaration.implementsClause, isNull);
-    expect(declaration.classKeyword, isNotNull);
-    expect(declaration.leftBracket, isNotNull);
-    expect(declaration.name, isNotNull);
-    expect(declaration.members, hasLength(1));
-    expect(declaration.rightBracket, isNotNull);
-    expect(declaration.typeParameters, isNull);
-  }
-
-  void test_parseClassDeclaration_typeAlias_implementsC() {
-    createParser('class A = Object with B implements C;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isClassTypeAlias);
-    ClassTypeAlias typeAlias = member;
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name, isNotNull);
-    _assertIsDeclarationName(typeAlias.name);
-    expect(typeAlias.typeParameters, isNull);
-    expect(typeAlias.withClause, isNotNull);
-    expect(typeAlias.implementsClause, isNotNull);
-    expect(typeAlias.implementsClause.implementsKeyword, isNotNull);
-    expect(typeAlias.implementsClause.interfaces.length, 1);
-    expect(typeAlias.semicolon, isNotNull);
-  }
-
-  void test_parseClassDeclaration_typeAlias_withB() {
-    createParser('class A = Object with B;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isClassTypeAlias);
-    ClassTypeAlias typeAlias = member;
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name, isNotNull);
-    expect(typeAlias.typeParameters, isNull);
-    expect(typeAlias.withClause, isNotNull);
-    expect(typeAlias.withClause.withKeyword, isNotNull);
-    expect(typeAlias.withClause.mixinTypes.length, 1);
-    expect(typeAlias.implementsClause, isNull);
-    expect(typeAlias.semicolon, isNotNull);
-  }
-
-  void test_parseClassDeclaration_typeParameters() {
-    createParser('class A<B> {}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isClassDeclaration);
-    ClassDeclaration declaration = member;
-    expect(declaration.documentationComment, isNull);
-    expect(declaration.abstractKeyword, isNull);
-    expect(declaration.extendsClause, isNull);
-    expect(declaration.implementsClause, isNull);
-    expect(declaration.classKeyword, isNotNull);
-    expect(declaration.leftBracket, isNotNull);
-    expect(declaration.name, isNotNull);
-    _assertIsDeclarationName(declaration.name);
-    expect(declaration.members, hasLength(0));
-    expect(declaration.rightBracket, isNotNull);
-    expect(declaration.typeParameters, isNotNull);
-    expect(declaration.typeParameters.typeParameters, hasLength(1));
-    _assertIsDeclarationName(declaration.typeParameters.typeParameters[0].name);
-  }
-
-  void test_parseClassDeclaration_typeParameters_extends_void() {
-    parseCompilationUnit('class C<T extends void>{}',
-        errors: [expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 18, 4)]);
-  }
-
-  void test_parseClassDeclaration_withDocumentationComment() {
-    createParser('/// Doc\nclass C {}');
-    var classDeclaration = parseFullCompilationUnitMember() as ClassDeclaration;
-    expectCommentText(classDeclaration.documentationComment, '/// Doc');
-  }
-
-  void test_parseClassTypeAlias_withDocumentationComment() {
-    createParser('/// Doc\nclass C = D with E;');
-    var classTypeAlias = parseFullCompilationUnitMember() as ClassTypeAlias;
-    expectCommentText(classTypeAlias.documentationComment, '/// Doc');
-  }
-
-  void test_parseCompilationUnit_abstractAsPrefix_parameterized() {
-    var errorCodes = <ErrorCode>[];
-    // This used to be deferred to later in the pipeline, but is now being
-    // reported by the parser.
-    errorCodes.add(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE);
-    CompilationUnit unit = parseCompilationUnit(
-        'abstract<dynamic> _abstract = new abstract.A();',
-        codes: errorCodes);
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(0));
-    expect(unit.declarations, hasLength(1));
-  }
-
-  void test_parseCompilationUnit_builtIn_asFunctionName() {
-    for (Keyword keyword in Keyword.values) {
-      if (keyword.isBuiltIn || keyword.isPseudo) {
-        String lexeme = keyword.lexeme;
-        if (lexeme == 'Function') continue;
-        parseCompilationUnit('$lexeme(x) => 0;');
-        parseCompilationUnit('class C {$lexeme(x) => 0;}');
-      }
-    }
-  }
-
-  void test_parseCompilationUnit_builtIn_asFunctionName_withTypeParameter() {
-    for (Keyword keyword in Keyword.values) {
-      if (keyword.isBuiltIn || keyword.isPseudo) {
-        String lexeme = keyword.lexeme;
-        if (lexeme == 'Function') continue;
-        // The fasta type resolution phase will report an error
-        // on type arguments on `dynamic` (e.g. `dynamic<int>`).
-        parseCompilationUnit('$lexeme<T>(x) => 0;');
-        parseCompilationUnit('class C {$lexeme<T>(x) => 0;}');
-      }
-    }
-  }
-
-  void test_parseCompilationUnit_builtIn_asGetter() {
-    for (Keyword keyword in Keyword.values) {
-      if (keyword.isBuiltIn || keyword.isPseudo) {
-        String lexeme = keyword.lexeme;
-        parseCompilationUnit('get $lexeme => 0;');
-        parseCompilationUnit('class C {get $lexeme => 0;}');
-      }
-    }
-  }
-
-  void test_parseCompilationUnit_directives_multiple() {
-    createParser("library l;\npart 'a.dart';");
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expect(unit, isNotNull);
-    assertNoErrors();
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(2));
-    expect(unit.declarations, hasLength(0));
-  }
-
-  void test_parseCompilationUnit_directives_single() {
-    createParser('library l;');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expect(unit, isNotNull);
-    assertNoErrors();
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(1));
-    expect(unit.declarations, hasLength(0));
-  }
-
-  void test_parseCompilationUnit_empty() {
-    createParser('');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expect(unit, isNotNull);
-    assertNoErrors();
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(0));
-    expect(unit.declarations, hasLength(0));
-    expect(unit.beginToken, isNotNull);
-    expect(unit.endToken, isNotNull);
-    expect(unit.endToken.type, TokenType.EOF);
-  }
-
-  void test_parseCompilationUnit_exportAsPrefix() {
-    createParser('export.A _export = new export.A();');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expect(unit, isNotNull);
-    assertNoErrors();
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(0));
-    expect(unit.declarations, hasLength(1));
-  }
-
-  void test_parseCompilationUnit_exportAsPrefix_parameterized() {
-    createParser('export<dynamic> _export = new export.A();');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expect(unit, isNotNull);
-    // This used to be deferred to later in the pipeline, but is now being
-    // reported by the parser.
-    assertErrorsWithCodes([CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE]);
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(0));
-    expect(unit.declarations, hasLength(1));
-  }
-
-  void test_parseCompilationUnit_operatorAsPrefix_parameterized() {
-    createParser('operator<dynamic> _operator = new operator.A();');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expect(unit, isNotNull);
-    // This used to be deferred to later in the pipeline, but is now being
-    // reported by the parser.
-    assertErrorsWithCodes([CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE]);
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(0));
-    expect(unit.declarations, hasLength(1));
-  }
-
-  void test_parseCompilationUnit_pseudo_asTypeName() {
-    for (Keyword keyword in Keyword.values) {
-      if (keyword.isPseudo) {
-        String lexeme = keyword.lexeme;
-        parseCompilationUnit('$lexeme f;');
-        parseCompilationUnit('class C {$lexeme f;}');
-        parseCompilationUnit('f($lexeme g) {}');
-        parseCompilationUnit('f() {$lexeme g;}');
-      }
-    }
-  }
-
-  void test_parseCompilationUnit_pseudo_prefixed() {
-    for (Keyword keyword in Keyword.values) {
-      if (keyword.isPseudo) {
-        String lexeme = keyword.lexeme;
-        parseCompilationUnit('M.$lexeme f;');
-        parseCompilationUnit('class C {M.$lexeme f;}');
-      }
-    }
-  }
-
-  void test_parseCompilationUnit_script() {
-    createParser('#! /bin/dart');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expect(unit, isNotNull);
-    assertNoErrors();
-    expect(unit.scriptTag, isNotNull);
-    expect(unit.directives, hasLength(0));
-    expect(unit.declarations, hasLength(0));
-  }
-
-  void test_parseCompilationUnit_skipFunctionBody_withInterpolation() {
-    ParserTestCase.parseFunctionBodies = false;
-    createParser('f() { "\${n}"; }');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expect(unit, isNotNull);
-    assertNoErrors();
-    expect(unit.scriptTag, isNull);
-    expect(unit.declarations, hasLength(1));
-  }
-
-  void test_parseCompilationUnit_topLevelDeclaration() {
-    createParser('class A {}');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expect(unit, isNotNull);
-    assertNoErrors();
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(0));
-    expect(unit.declarations, hasLength(1));
-    expect(unit.beginToken, isNotNull);
-    expect(unit.beginToken.keyword, Keyword.CLASS);
-    expect(unit.endToken, isNotNull);
-    expect(unit.endToken.type, TokenType.EOF);
-  }
-
-  void test_parseCompilationUnit_typedefAsPrefix() {
-    createParser('typedef.A _typedef = new typedef.A();');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    expect(unit, isNotNull);
-    assertNoErrors();
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(0));
-    expect(unit.declarations, hasLength(1));
-  }
-
-  void test_parseCompilationUnitMember_abstractAsPrefix() {
-    createParser('abstract.A _abstract = new abstract.A();');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isTopLevelVariableDeclaration);
-    TopLevelVariableDeclaration declaration = member;
-    expect(declaration.semicolon, isNotNull);
-    expect(declaration.variables, isNotNull);
-  }
-
-  void test_parseCompilationUnitMember_class() {
-    createParser('class A {}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isClassDeclaration);
-    ClassDeclaration declaration = member;
-    expect(declaration.name.name, "A");
-    expect(declaration.members, hasLength(0));
-  }
-
-  void test_parseCompilationUnitMember_classTypeAlias() {
-    createParser('abstract class A = B with C;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isClassTypeAlias);
-    ClassTypeAlias declaration = member;
-    expect(declaration.name.name, "A");
-    expect(declaration.abstractKeyword, isNotNull);
-  }
-
-  void test_parseCompilationUnitMember_constVariable() {
-    createParser('const int x = 0;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isTopLevelVariableDeclaration);
-    TopLevelVariableDeclaration declaration = member;
-    expect(declaration.semicolon, isNotNull);
-    expect(declaration.variables, isNotNull);
-    expect(declaration.variables.keyword.lexeme, 'const');
-    _assertIsDeclarationName(declaration.variables.variables[0].name);
-  }
-
-  void test_parseCompilationUnitMember_expressionFunctionBody_tokens() {
-    createParser('f() => 0;');
-    var f = parseFullCompilationUnitMember() as FunctionDeclaration;
-    var body = f.functionExpression.body as ExpressionFunctionBody;
-    expect(body.functionDefinition.lexeme, '=>');
-    expect(body.semicolon.lexeme, ';');
-    _assertIsDeclarationName(f.name);
-  }
-
-  void test_parseCompilationUnitMember_finalVariable() {
-    createParser('final x = 0;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isTopLevelVariableDeclaration);
-    TopLevelVariableDeclaration declaration = member;
-    expect(declaration.semicolon, isNotNull);
-    expect(declaration.variables, isNotNull);
-    expect(declaration.variables.keyword.lexeme, 'final');
-  }
-
-  void test_parseCompilationUnitMember_function_external_noType() {
-    createParser('external f();');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFunctionDeclaration);
-    FunctionDeclaration declaration = member;
-    expect(declaration.externalKeyword, isNotNull);
-    expect(declaration.functionExpression, isNotNull);
-    expect(declaration.propertyKeyword, isNull);
-  }
-
-  void test_parseCompilationUnitMember_function_external_type() {
-    createParser('external int f();');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFunctionDeclaration);
-    FunctionDeclaration declaration = member;
-    expect(declaration.externalKeyword, isNotNull);
-    expect(declaration.functionExpression, isNotNull);
-    expect(declaration.propertyKeyword, isNull);
-  }
-
-  void test_parseCompilationUnitMember_function_generic_noReturnType() {
-    createParser('f<E>() {}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFunctionDeclaration);
-    FunctionDeclaration declaration = member;
-    expect(declaration.returnType, isNull);
-    expect(declaration.functionExpression.typeParameters, isNotNull);
-  }
-
-  void
-      test_parseCompilationUnitMember_function_generic_noReturnType_annotated() {
-    createParser('f<@a E>() {}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFunctionDeclaration);
-    FunctionDeclaration declaration = member;
-    expect(declaration.returnType, isNull);
-    expect(declaration.functionExpression.typeParameters, isNotNull);
-  }
-
-  void test_parseCompilationUnitMember_function_generic_returnType() {
-    createParser('E f<E>() {}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFunctionDeclaration);
-    FunctionDeclaration declaration = member;
-    expect(declaration.returnType, isNotNull);
-    expect(declaration.functionExpression.typeParameters, isNotNull);
-  }
-
-  void test_parseCompilationUnitMember_function_generic_void() {
-    createParser('void f<T>(T t) {}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFunctionDeclaration);
-    FunctionDeclaration declaration = member;
-    expect(declaration.functionExpression, isNotNull);
-    expect(declaration.propertyKeyword, isNull);
-  }
-
-  void test_parseCompilationUnitMember_function_gftReturnType() {
-    createParser('''
-void Function<A>(core.List<core.int> x) f() => null;
-''');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    assertNoErrors();
-    expect(unit, isNotNull);
-    expect(unit.declarations, hasLength(1));
-  }
-
-  void test_parseCompilationUnitMember_function_noReturnType() {
-    createParser('''
-Function<A>(core.List<core.int> x) f() => null;
-''');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    assertNoErrors();
-    expect(unit, isNotNull);
-    expect(unit.declarations, hasLength(1));
-  }
-
-  void test_parseCompilationUnitMember_function_noType() {
-    createParser('f() {}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFunctionDeclaration);
-    FunctionDeclaration declaration = member;
-    expect(declaration.functionExpression, isNotNull);
-    expect(declaration.propertyKeyword, isNull);
-  }
-
-  void test_parseCompilationUnitMember_function_type() {
-    createParser('int f() {}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFunctionDeclaration);
-    FunctionDeclaration declaration = member;
-    expect(declaration.functionExpression, isNotNull);
-    expect(declaration.propertyKeyword, isNull);
-  }
-
-  void test_parseCompilationUnitMember_function_void() {
-    createParser('void f() {}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFunctionDeclaration);
-    FunctionDeclaration declaration = member;
-    expect(declaration.returnType, isNotNull);
-  }
-
-  void test_parseCompilationUnitMember_getter_external_noType() {
-    createParser('external get p;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFunctionDeclaration);
-    FunctionDeclaration declaration = member;
-    expect(declaration.externalKeyword, isNotNull);
-    expect(declaration.functionExpression, isNotNull);
-    expect(declaration.propertyKeyword, isNotNull);
-    _assertIsDeclarationName(declaration.name);
-  }
-
-  void test_parseCompilationUnitMember_getter_external_type() {
-    createParser('external int get p;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFunctionDeclaration);
-    FunctionDeclaration declaration = member;
-    expect(declaration.externalKeyword, isNotNull);
-    expect(declaration.functionExpression, isNotNull);
-    expect(declaration.propertyKeyword, isNotNull);
-  }
-
-  void test_parseCompilationUnitMember_getter_noType() {
-    createParser('get p => 0;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFunctionDeclaration);
-    FunctionDeclaration declaration = member;
-    expect(declaration.functionExpression, isNotNull);
-    expect(declaration.propertyKeyword, isNotNull);
-  }
-
-  void test_parseCompilationUnitMember_getter_type() {
-    createParser('int get p => 0;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFunctionDeclaration);
-    FunctionDeclaration declaration = member;
-    expect(declaration.functionExpression, isNotNull);
-    expect(declaration.propertyKeyword, isNotNull);
-  }
-
-  void test_parseCompilationUnitMember_setter_external_noType() {
-    createParser('external set p(v);');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFunctionDeclaration);
-    FunctionDeclaration declaration = member;
-    expect(declaration.externalKeyword, isNotNull);
-    expect(declaration.functionExpression, isNotNull);
-    expect(declaration.propertyKeyword, isNotNull);
-  }
-
-  void test_parseCompilationUnitMember_setter_external_type() {
-    createParser('external void set p(int v);');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFunctionDeclaration);
-    FunctionDeclaration declaration = member;
-    expect(declaration.externalKeyword, isNotNull);
-    expect(declaration.functionExpression, isNotNull);
-    expect(declaration.propertyKeyword, isNotNull);
-  }
-
-  void test_parseCompilationUnitMember_setter_noType() {
-    createParser('set p(v) {}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFunctionDeclaration);
-    FunctionDeclaration declaration = member;
-    expect(declaration.functionExpression, isNotNull);
-    expect(declaration.propertyKeyword, isNotNull);
-    _assertIsDeclarationName(declaration.name);
-  }
-
-  void test_parseCompilationUnitMember_setter_type() {
-    createParser('void set p(int v) {}');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isFunctionDeclaration);
-    FunctionDeclaration declaration = member;
-    expect(declaration.functionExpression, isNotNull);
-    expect(declaration.propertyKeyword, isNotNull);
-    expect(declaration.returnType, isNotNull);
-  }
-
-  void test_parseCompilationUnitMember_typeAlias_abstract() {
-    createParser('abstract class C = S with M;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isClassTypeAlias);
-    ClassTypeAlias typeAlias = member;
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name.name, "C");
-    _assertIsDeclarationName(typeAlias.name);
-    expect(typeAlias.typeParameters, isNull);
-    expect(typeAlias.equals, isNotNull);
-    expect(typeAlias.abstractKeyword, isNotNull);
-    expect(typeAlias.superclass.name.name, "S");
-    expect(typeAlias.withClause, isNotNull);
-    expect(typeAlias.implementsClause, isNull);
-    expect(typeAlias.semicolon, isNotNull);
-  }
-
-  void test_parseCompilationUnitMember_typeAlias_generic() {
-    createParser('class C<E> = S<E> with M<E> implements I<E>;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isClassTypeAlias);
-    ClassTypeAlias typeAlias = member;
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name.name, "C");
-    expect(typeAlias.typeParameters.typeParameters, hasLength(1));
-    expect(typeAlias.equals, isNotNull);
-    expect(typeAlias.abstractKeyword, isNull);
-    expect(typeAlias.superclass.name.name, "S");
-    expect(typeAlias.withClause, isNotNull);
-    expect(typeAlias.implementsClause, isNotNull);
-    expect(typeAlias.semicolon, isNotNull);
-  }
-
-  void test_parseCompilationUnitMember_typeAlias_implements() {
-    createParser('class C = S with M implements I;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isClassTypeAlias);
-    ClassTypeAlias typeAlias = member;
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name.name, "C");
-    expect(typeAlias.typeParameters, isNull);
-    expect(typeAlias.equals, isNotNull);
-    expect(typeAlias.abstractKeyword, isNull);
-    expect(typeAlias.superclass.name.name, "S");
-    expect(typeAlias.withClause, isNotNull);
-    expect(typeAlias.implementsClause, isNotNull);
-    expect(typeAlias.semicolon, isNotNull);
-  }
-
-  void test_parseCompilationUnitMember_typeAlias_noImplements() {
-    createParser('class C = S with M;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isClassTypeAlias);
-    ClassTypeAlias typeAlias = member;
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name.name, "C");
-    expect(typeAlias.typeParameters, isNull);
-    expect(typeAlias.equals, isNotNull);
-    expect(typeAlias.abstractKeyword, isNull);
-    expect(typeAlias.superclass.name.name, "S");
-    expect(typeAlias.withClause, isNotNull);
-    expect(typeAlias.implementsClause, isNull);
-    expect(typeAlias.semicolon, isNotNull);
-  }
-
-  void test_parseCompilationUnitMember_typedef() {
-    createParser('typedef F();');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, TypeMatcher<FunctionTypeAlias>());
-    FunctionTypeAlias typeAlias = member;
-    expect(typeAlias.name.name, "F");
-    expect(typeAlias.parameters.parameters, hasLength(0));
-    _assertIsDeclarationName(typeAlias.name);
-  }
-
-  void test_parseCompilationUnitMember_typedef_withDocComment() {
-    createParser('/// Doc\ntypedef F();');
-    var typeAlias = parseFullCompilationUnitMember() as FunctionTypeAlias;
-    expectCommentText(typeAlias.documentationComment, '/// Doc');
-  }
-
-  void test_parseCompilationUnitMember_typedVariable() {
-    createParser('int x = 0;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isTopLevelVariableDeclaration);
-    TopLevelVariableDeclaration declaration = member;
-    expect(declaration.semicolon, isNotNull);
-    expect(declaration.variables, isNotNull);
-    expect(declaration.variables.type, isNotNull);
-    expect(declaration.variables.keyword, isNull);
-    _assertIsDeclarationName(declaration.variables.variables[0].name);
-  }
-
-  void test_parseCompilationUnitMember_variable() {
-    createParser('var x = 0;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isTopLevelVariableDeclaration);
-    TopLevelVariableDeclaration declaration = member;
-    expect(declaration.semicolon, isNotNull);
-    expect(declaration.variables, isNotNull);
-    expect(declaration.variables.keyword.lexeme, 'var');
-  }
-
-  void test_parseCompilationUnitMember_variable_gftType_gftReturnType() {
-    createParser('''
-Function(int) Function(String) v;
-''');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    assertNoErrors();
-    expect(unit, isNotNull);
-    expect(unit.declarations, hasLength(1));
-    TopLevelVariableDeclaration declaration =
-        unit.declarations[0] as TopLevelVariableDeclaration;
-    expect(declaration.variables.type, isGenericFunctionType);
-  }
-
-  void test_parseCompilationUnitMember_variable_gftType_noReturnType() {
-    createParser('''
-Function(int, String) v;
-''');
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    assertNoErrors();
-    expect(unit, isNotNull);
-    expect(unit.declarations, hasLength(1));
-  }
-
-  void test_parseCompilationUnitMember_variable_withDocumentationComment() {
-    createParser('/// Doc\nvar x = 0;');
-    var declaration =
-        parseFullCompilationUnitMember() as TopLevelVariableDeclaration;
-    expectCommentText(declaration.documentationComment, '/// Doc');
-  }
-
-  void test_parseCompilationUnitMember_variableGet() {
-    createParser('String get = null;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isTopLevelVariableDeclaration);
-    TopLevelVariableDeclaration declaration = member;
-    expect(declaration.semicolon, isNotNull);
-    expect(declaration.variables, isNotNull);
-  }
-
-  void test_parseCompilationUnitMember_variableSet() {
-    createParser('String set = null;');
-    CompilationUnitMember member = parseFullCompilationUnitMember();
-    expect(member, isNotNull);
-    assertNoErrors();
-    expect(member, isTopLevelVariableDeclaration);
-    TopLevelVariableDeclaration declaration = member;
-    expect(declaration.semicolon, isNotNull);
-    expect(declaration.variables, isNotNull);
-  }
-
-  void test_parseDirective_export() {
-    createParser("export 'lib/lib.dart';");
-    Directive directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive, TypeMatcher<ExportDirective>());
-    ExportDirective exportDirective = directive;
-    expect(exportDirective.keyword, isNotNull);
-    expect(exportDirective.uri, isNotNull);
-    expect(exportDirective.combinators, hasLength(0));
-    expect(exportDirective.semicolon, isNotNull);
-  }
-
-  void test_parseDirective_export_withDocComment() {
-    createParser("/// Doc\nexport 'foo.dart';");
-    var directive = parseFullDirective() as ExportDirective;
-    expectCommentText(directive.documentationComment, '/// Doc');
-  }
-
-  void test_parseDirective_import() {
-    createParser("import 'lib/lib.dart';");
-    Directive directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive, TypeMatcher<ImportDirective>());
-    ImportDirective importDirective = directive;
-    expect(importDirective.keyword, isNotNull);
-    expect(importDirective.uri, isNotNull);
-    expect(importDirective.asKeyword, isNull);
-    expect(importDirective.prefix, isNull);
-    expect(importDirective.combinators, hasLength(0));
-    expect(importDirective.semicolon, isNotNull);
-  }
-
-  void test_parseDirective_library() {
-    createParser("library l;");
-    Directive directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive, TypeMatcher<LibraryDirective>());
-    LibraryDirective libraryDirective = directive;
-    expect(libraryDirective.libraryKeyword, isNotNull);
-    expect(libraryDirective.name, isNotNull);
-    expect(libraryDirective.semicolon, isNotNull);
-  }
-
-  void test_parseDirective_library_1_component() {
-    createParser("library a;");
-    var lib = parseFullDirective() as LibraryDirective;
-    expect(lib.name.components, hasLength(1));
-    expect(lib.name.components[0].name, 'a');
-  }
-
-  void test_parseDirective_library_2_components() {
-    createParser("library a.b;");
-    var lib = parseFullDirective() as LibraryDirective;
-    expect(lib.name.components, hasLength(2));
-    expect(lib.name.components[0].name, 'a');
-    expect(lib.name.components[1].name, 'b');
-  }
-
-  void test_parseDirective_library_3_components() {
-    createParser("library a.b.c;");
-    var lib = parseFullDirective() as LibraryDirective;
-    expect(lib.name.components, hasLength(3));
-    expect(lib.name.components[0].name, 'a');
-    expect(lib.name.components[1].name, 'b');
-    expect(lib.name.components[2].name, 'c');
-  }
-
-  void test_parseDirective_library_annotation() {
-    createParser("@A library l;");
-    Directive directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive, TypeMatcher<LibraryDirective>());
-    LibraryDirective libraryDirective = directive;
-    expect(libraryDirective.libraryKeyword, isNotNull);
-    expect(libraryDirective.name, isNotNull);
-    expect(libraryDirective.semicolon, isNotNull);
-    expect(libraryDirective.metadata, hasLength(1));
-    expect(libraryDirective.metadata[0].name.name, 'A');
-  }
-
-  void test_parseDirective_library_annotation2() {
-    createParser("@A library l;");
-    CompilationUnit unit = parser.parseCompilationUnit2();
-    Directive directive = unit.directives[0];
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive, TypeMatcher<LibraryDirective>());
-    LibraryDirective libraryDirective = directive;
-    expect(libraryDirective.libraryKeyword, isNotNull);
-    expect(libraryDirective.name, isNotNull);
-    expect(libraryDirective.semicolon, isNotNull);
-    expect(libraryDirective.metadata, hasLength(1));
-    expect(libraryDirective.metadata[0].name.name, 'A');
-  }
-
-  void test_parseDirective_library_withDocumentationComment() {
-    createParser('/// Doc\nlibrary l;');
-    var directive = parseFullDirective() as LibraryDirective;
-    expectCommentText(directive.documentationComment, '/// Doc');
-  }
-
-  void test_parseDirective_part() {
-    createParser("part 'lib/lib.dart';");
-    Directive directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive, TypeMatcher<PartDirective>());
-    PartDirective partDirective = directive;
-    expect(partDirective.partKeyword, isNotNull);
-    expect(partDirective.uri, isNotNull);
-    expect(partDirective.semicolon, isNotNull);
-  }
-
-  void test_parseDirective_part_of_1_component() {
-    createParser("part of a;");
-    var partOf = parseFullDirective() as PartOfDirective;
-    expect(partOf.libraryName.components, hasLength(1));
-    expect(partOf.libraryName.components[0].name, 'a');
-  }
-
-  void test_parseDirective_part_of_2_components() {
-    createParser("part of a.b;");
-    var partOf = parseFullDirective() as PartOfDirective;
-    expect(partOf.libraryName.components, hasLength(2));
-    expect(partOf.libraryName.components[0].name, 'a');
-    expect(partOf.libraryName.components[1].name, 'b');
-  }
-
-  void test_parseDirective_part_of_3_components() {
-    createParser("part of a.b.c;");
-    var partOf = parseFullDirective() as PartOfDirective;
-    expect(partOf.libraryName.components, hasLength(3));
-    expect(partOf.libraryName.components[0].name, 'a');
-    expect(partOf.libraryName.components[1].name, 'b');
-    expect(partOf.libraryName.components[2].name, 'c');
-  }
-
-  void test_parseDirective_part_of_withDocumentationComment() {
-    createParser('/// Doc\npart of a;');
-    var partOf = parseFullDirective() as PartOfDirective;
-    expectCommentText(partOf.documentationComment, '/// Doc');
-  }
-
-  void test_parseDirective_part_withDocumentationComment() {
-    createParser("/// Doc\npart 'lib.dart';");
-    var directive = parseFullDirective() as PartDirective;
-    expectCommentText(directive.documentationComment, '/// Doc');
-  }
-
-  void test_parseDirective_partOf() {
-    createParser("part of l;");
-    Directive directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive, TypeMatcher<PartOfDirective>());
-    PartOfDirective partOfDirective = directive;
-    expect(partOfDirective.partKeyword, isNotNull);
-    expect(partOfDirective.ofKeyword, isNotNull);
-    expect(partOfDirective.libraryName, isNotNull);
-    expect(partOfDirective.semicolon, isNotNull);
-  }
-
-  void test_parseDirectives_annotations() {
-    CompilationUnit unit =
-        parseDirectives("@A library l; @B import 'foo.dart';");
-    expect(unit.directives, hasLength(2));
-    expect(unit.directives[0].metadata[0].name.name, 'A');
-    expect(unit.directives[1].metadata[0].name.name, 'B');
-  }
-
-  void test_parseDirectives_complete() {
-    CompilationUnit unit =
-        parseDirectives("#! /bin/dart\nlibrary l;\nclass A {}");
-    expect(unit.scriptTag, isNotNull);
-    expect(unit.directives, hasLength(1));
-  }
-
-  void test_parseDirectives_empty() {
-    CompilationUnit unit = parseDirectives("");
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(0));
-  }
-
-  void test_parseDirectives_mixed() {
-    CompilationUnit unit =
-        parseDirectives("library l; class A {} part 'foo.dart';");
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(1));
-  }
-
-  void test_parseDirectives_multiple() {
-    CompilationUnit unit = parseDirectives("library l;\npart 'a.dart';");
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(2));
-  }
-
-  void test_parseDirectives_script() {
-    CompilationUnit unit = parseDirectives("#! /bin/dart");
-    expect(unit.scriptTag, isNotNull);
-    expect(unit.directives, hasLength(0));
-  }
-
-  void test_parseDirectives_single() {
-    CompilationUnit unit = parseDirectives("library l;");
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(1));
-  }
-
-  void test_parseDirectives_topLevelDeclaration() {
-    CompilationUnit unit = parseDirectives("class A {}");
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(0));
-  }
-
-  void test_parseEnumDeclaration_one() {
-    createParser("enum E {ONE}");
-    EnumDeclaration declaration = parseFullCompilationUnitMember();
-    expect(declaration, isNotNull);
-    assertNoErrors();
-    expect(declaration.documentationComment, isNull);
-    expect(declaration.enumKeyword, isNotNull);
-    expect(declaration.leftBracket, isNotNull);
-    expect(declaration.name, isNotNull);
-    expect(declaration.constants, hasLength(1));
-    expect(declaration.rightBracket, isNotNull);
-  }
-
-  void test_parseEnumDeclaration_trailingComma() {
-    createParser("enum E {ONE,}");
-    EnumDeclaration declaration = parseFullCompilationUnitMember();
-    expect(declaration, isNotNull);
-    assertNoErrors();
-    expect(declaration.documentationComment, isNull);
-    expect(declaration.enumKeyword, isNotNull);
-    expect(declaration.leftBracket, isNotNull);
-    expect(declaration.name, isNotNull);
-    expect(declaration.constants, hasLength(1));
-    expect(declaration.rightBracket, isNotNull);
-  }
-
-  void test_parseEnumDeclaration_two() {
-    createParser("enum E {ONE, TWO}");
-    EnumDeclaration declaration = parseFullCompilationUnitMember();
-    expect(declaration, isNotNull);
-    assertNoErrors();
-    expect(declaration.documentationComment, isNull);
-    expect(declaration.enumKeyword, isNotNull);
-    expect(declaration.leftBracket, isNotNull);
-    expect(declaration.name, isNotNull);
-    expect(declaration.constants, hasLength(2));
-    expect(declaration.rightBracket, isNotNull);
-  }
-
-  void test_parseEnumDeclaration_withDocComment_onEnum() {
-    createParser('/// Doc\nenum E {ONE}');
-    var declaration = parseFullCompilationUnitMember() as EnumDeclaration;
-    expectCommentText(declaration.documentationComment, '/// Doc');
-  }
-
-  void test_parseEnumDeclaration_withDocComment_onValue() {
-    createParser('''
-enum E {
-  /// Doc
-  ONE
-}''');
-    var declaration = parseFullCompilationUnitMember() as EnumDeclaration;
-    var value = declaration.constants[0];
-    expectCommentText(value.documentationComment, '/// Doc');
-  }
-
-  void test_parseEnumDeclaration_withDocComment_onValue_annotated() {
-    createParser('''
-enum E {
-  /// Doc
-  @annotation
-  ONE
-}
-''');
-    var declaration = parseFullCompilationUnitMember() as EnumDeclaration;
-    var value = declaration.constants[0];
-    expectCommentText(value.documentationComment, '/// Doc');
-    expect(value.metadata, hasLength(1));
-  }
-
-  void test_parseExportDirective_configuration_multiple() {
-    createParser("export 'lib/lib.dart' if (a) 'b.dart' if (c) 'd.dart';");
-    ExportDirective directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive.keyword, isNotNull);
-    expect(directive.uri, isNotNull);
-    expect(directive.configurations, hasLength(2));
-    expectDottedName(directive.configurations[0].name, ['a']);
-    expectDottedName(directive.configurations[1].name, ['c']);
-    expect(directive.combinators, hasLength(0));
-    expect(directive.semicolon, isNotNull);
-  }
-
-  void test_parseExportDirective_configuration_single() {
-    createParser("export 'lib/lib.dart' if (a.b == 'c.dart') '';");
-    ExportDirective directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive.keyword, isNotNull);
-    expect(directive.uri, isNotNull);
-    expect(directive.configurations, hasLength(1));
-    expectDottedName(directive.configurations[0].name, ['a', 'b']);
-    expect(directive.combinators, hasLength(0));
-    expect(directive.semicolon, isNotNull);
-  }
-
-  void test_parseExportDirective_hide() {
-    createParser("export 'lib/lib.dart' hide A, B;");
-    ExportDirective directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive.keyword, isNotNull);
-    expect(directive.uri, isNotNull);
-    expect(directive.combinators, hasLength(1));
-    expect(directive.semicolon, isNotNull);
-  }
-
-  void test_parseExportDirective_hide_show() {
-    createParser("export 'lib/lib.dart' hide A show B;");
-    ExportDirective directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive.keyword, isNotNull);
-    expect(directive.uri, isNotNull);
-    expect(directive.combinators, hasLength(2));
-    expect(directive.semicolon, isNotNull);
-  }
-
-  void test_parseExportDirective_noCombinator() {
-    createParser("export 'lib/lib.dart';");
-    ExportDirective directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive.keyword, isNotNull);
-    expect(directive.uri, isNotNull);
-    expect(directive.combinators, hasLength(0));
-    expect(directive.semicolon, isNotNull);
-  }
-
-  void test_parseExportDirective_show() {
-    createParser("export 'lib/lib.dart' show A, B;");
-    ExportDirective directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive.keyword, isNotNull);
-    expect(directive.uri, isNotNull);
-    expect(directive.combinators, hasLength(1));
-    expect(directive.semicolon, isNotNull);
-  }
-
-  void test_parseExportDirective_show_hide() {
-    createParser("export 'lib/lib.dart' show B hide A;");
-    ExportDirective directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive.keyword, isNotNull);
-    expect(directive.uri, isNotNull);
-    expect(directive.combinators, hasLength(2));
-    expect(directive.semicolon, isNotNull);
-  }
-
-  void test_parseFunctionDeclaration_function() {
-    createParser('/// Doc\nT f() {}');
-    FunctionDeclaration declaration = parseFullCompilationUnitMember();
-    expect(declaration, isNotNull);
-    assertNoErrors();
-    expectCommentText(declaration.documentationComment, '/// Doc');
-    expect((declaration.returnType as TypeName).name.name, 'T');
-    expect(declaration.name, isNotNull);
-    FunctionExpression expression = declaration.functionExpression;
-    expect(expression, isNotNull);
-    expect(expression.body, isNotNull);
-    expect(expression.typeParameters, isNull);
-    expect(expression.parameters, isNotNull);
-    expect(declaration.propertyKeyword, isNull);
-  }
-
-  void test_parseFunctionDeclaration_functionWithTypeParameters() {
-    createParser('/// Doc\nT f<E>() {}');
-    FunctionDeclaration declaration = parseFullCompilationUnitMember();
-    expect(declaration, isNotNull);
-    assertNoErrors();
-    expectCommentText(declaration.documentationComment, '/// Doc');
-    expect((declaration.returnType as TypeName).name.name, 'T');
-    expect(declaration.name, isNotNull);
-    FunctionExpression expression = declaration.functionExpression;
-    expect(expression, isNotNull);
-    expect(expression.body, isNotNull);
-    expect(expression.typeParameters, isNotNull);
-    expect(expression.parameters, isNotNull);
-    expect(declaration.propertyKeyword, isNull);
-  }
-
-  void test_parseFunctionDeclaration_getter() {
-    createParser('/// Doc\nT get p => 0;');
-    FunctionDeclaration declaration = parseFullCompilationUnitMember();
-    expect(declaration, isNotNull);
-    assertNoErrors();
-    expectCommentText(declaration.documentationComment, '/// Doc');
-    expect((declaration.returnType as TypeName).name.name, 'T');
-    expect(declaration.name, isNotNull);
-    FunctionExpression expression = declaration.functionExpression;
-    expect(expression, isNotNull);
-    expect(expression.body, isNotNull);
-    expect(expression.typeParameters, isNull);
-    expect(expression.parameters, isNull);
-    expect(declaration.propertyKeyword, isNotNull);
-  }
-
-  void test_parseFunctionDeclaration_metadata() {
-    createParser(
-        'T f(@A a, @B(2) Foo b, {@C.foo(3) c : 0, @d.E.bar(4, 5) x:0}) {}');
-    FunctionDeclaration declaration = parseFullCompilationUnitMember();
-    expect(declaration, isNotNull);
-    assertNoErrors();
-    expect(declaration.documentationComment, isNull);
-    expect((declaration.returnType as TypeName).name.name, 'T');
-    expect(declaration.name, isNotNull);
-    FunctionExpression expression = declaration.functionExpression;
-    expect(expression, isNotNull);
-    expect(expression.body, isNotNull);
-    expect(expression.typeParameters, isNull);
-    NodeList<FormalParameter> parameters = expression.parameters.parameters;
-    expect(parameters, hasLength(4));
-    expect(declaration.propertyKeyword, isNull);
-
-    {
-      var annotation = parameters[0].metadata[0];
-      expect(annotation.atSign, isNotNull);
-      expect(annotation.name, isSimpleIdentifier);
-      expect(annotation.name.name, 'A');
-      expect(annotation.period, isNull);
-      expect(annotation.constructorName, isNull);
-      expect(annotation.arguments, isNull);
-    }
-
-    {
-      var annotation = parameters[1].metadata[0];
-      expect(annotation.atSign, isNotNull);
-      expect(annotation.name, isSimpleIdentifier);
-      expect(annotation.name.name, 'B');
-      expect(annotation.period, isNull);
-      expect(annotation.constructorName, isNull);
-      expect(annotation.arguments, isNotNull);
-      expect(annotation.arguments.arguments, hasLength(1));
-    }
-
-    {
-      var annotation = parameters[2].metadata[0];
-      expect(annotation.atSign, isNotNull);
-      expect(annotation.name, isPrefixedIdentifier);
-      expect(annotation.name.name, 'C.foo');
-      expect(annotation.period, isNull);
-      expect(annotation.constructorName, isNull);
-      expect(annotation.arguments, isNotNull);
-      expect(annotation.arguments.arguments, hasLength(1));
-    }
-
-    {
-      var annotation = parameters[3].metadata[0];
-      expect(annotation.atSign, isNotNull);
-      expect(annotation.name, isPrefixedIdentifier);
-      expect(annotation.name.name, 'd.E');
-      expect(annotation.period, isNotNull);
-      expect(annotation.constructorName, isNotNull);
-      expect(annotation.constructorName.name, 'bar');
-      expect(annotation.arguments, isNotNull);
-      expect(annotation.arguments.arguments, hasLength(2));
-    }
-  }
-
-  void test_parseFunctionDeclaration_setter() {
-    createParser('/// Doc\nT set p(v) {}');
-    FunctionDeclaration declaration = parseFullCompilationUnitMember();
-    expect(declaration, isNotNull);
-    assertNoErrors();
-    expectCommentText(declaration.documentationComment, '/// Doc');
-    expect((declaration.returnType as TypeName).name.name, 'T');
-    expect(declaration.name, isNotNull);
-    FunctionExpression expression = declaration.functionExpression;
-    expect(expression, isNotNull);
-    expect(expression.body, isNotNull);
-    expect(expression.typeParameters, isNull);
-    expect(expression.parameters, isNotNull);
-    expect(declaration.propertyKeyword, isNotNull);
-  }
-
-  void test_parseGenericTypeAlias_noTypeParameters() {
-    createParser('typedef F = int Function(int);');
-    GenericTypeAlias alias = parseFullCompilationUnitMember();
-    expect(alias, isNotNull);
-    assertNoErrors();
-    expect(alias.name, isNotNull);
-    expect(alias.name.name, 'F');
-    expect(alias.typeParameters, isNull);
-    expect(alias.equals, isNotNull);
-    expect(alias.functionType, isNotNull);
-    expect(alias.semicolon, isNotNull);
-  }
-
-  void test_parseGenericTypeAlias_typeParameters() {
-    createParser('typedef F<T> = T Function(T);');
-    GenericTypeAlias alias = parseFullCompilationUnitMember();
-    expect(alias, isNotNull);
-    assertNoErrors();
-    expect(alias.name, isNotNull);
-    expect(alias.name.name, 'F');
-    expect(alias.typeParameters.typeParameters, hasLength(1));
-    expect(alias.equals, isNotNull);
-    expect(alias.functionType, isNotNull);
-    expect(alias.semicolon, isNotNull);
-  }
-
-  void test_parseGenericTypeAlias_typeParameters2() {
-    // The scanner creates a single token for `>=`
-    // then the parser must split it into two separate tokens.
-    createParser('typedef F<T>= T Function(T);');
-    GenericTypeAlias alias = parseFullCompilationUnitMember();
-    expect(alias, isNotNull);
-    assertNoErrors();
-    expect(alias.name, isNotNull);
-    expect(alias.name.name, 'F');
-    expect(alias.typeParameters.typeParameters, hasLength(1));
-    expect(alias.equals, isNotNull);
-    expect(alias.functionType, isNotNull);
-    expect(alias.semicolon, isNotNull);
-  }
-
-  void test_parseGenericTypeAlias_typeParameters3() {
-    createParser('typedef F<A,B,C> = Function(A a, B b, C c);');
-    GenericTypeAlias alias = parseFullCompilationUnitMember();
-    expect(alias, isNotNull);
-    assertNoErrors();
-    expect(alias.name, isNotNull);
-    expect(alias.name.name, 'F');
-    expect(alias.typeParameters.typeParameters, hasLength(3));
-    expect(alias.equals, isNotNull);
-    expect(alias.functionType, isNotNull);
-    expect(alias.semicolon, isNotNull);
-  }
-
-  void test_parseGenericTypeAlias_typeParameters3_gtEq() {
-    // The scanner creates a single token for `>=`
-    // then the parser must split it into two separate tokens.
-    createParser('typedef F<A,B,C>=Function(A a, B b, C c);');
-    GenericTypeAlias alias = parseFullCompilationUnitMember();
-    expect(alias, isNotNull);
-    assertNoErrors();
-    expect(alias.name, isNotNull);
-    expect(alias.name.name, 'F');
-    expect(alias.typeParameters.typeParameters, hasLength(3));
-    expect(alias.equals, isNotNull);
-    expect(alias.functionType, isNotNull);
-    expect(alias.semicolon, isNotNull);
-  }
-
-  void test_parseGenericTypeAlias_typeParameters_extends() {
-    createParser('typedef F<A,B,C extends D<E>> = Function(A a, B b, C c);');
-    GenericTypeAlias alias = parseFullCompilationUnitMember();
-    expect(alias, isNotNull);
-    assertNoErrors();
-    expect(alias.name, isNotNull);
-    expect(alias.name.name, 'F');
-    expect(alias.typeParameters.typeParameters, hasLength(3));
-    TypeParameter typeParam = alias.typeParameters.typeParameters[2];
-    NamedType type = typeParam.bound;
-    expect(type.typeArguments.arguments, hasLength(1));
-    expect(alias.equals, isNotNull);
-    expect(alias.functionType, isNotNull);
-    expect(alias.semicolon, isNotNull);
-  }
-
-  void test_parseGenericTypeAlias_typeParameters_extends3() {
-    createParser(
-        'typedef F<A,B,C extends D<E,G,H>> = Function(A a, B b, C c);');
-    GenericTypeAlias alias = parseFullCompilationUnitMember();
-    expect(alias, isNotNull);
-    assertNoErrors();
-    expect(alias.name, isNotNull);
-    expect(alias.name.name, 'F');
-    expect(alias.typeParameters.typeParameters, hasLength(3));
-    TypeParameter typeParam = alias.typeParameters.typeParameters[2];
-    NamedType type = typeParam.bound;
-    expect(type.typeArguments.arguments, hasLength(3));
-    expect(alias.equals, isNotNull);
-    expect(alias.functionType, isNotNull);
-    expect(alias.semicolon, isNotNull);
-  }
-
-  void test_parseGenericTypeAlias_typeParameters_extends3_gtGtEq() {
-    // The scanner creates a single token for `>>=`
-    // then the parser must split it into three separate tokens.
-    createParser('typedef F<A,B,C extends D<E,G,H>>=Function(A a, B b, C c);');
-    GenericTypeAlias alias = parseFullCompilationUnitMember();
-    expect(alias, isNotNull);
-    assertNoErrors();
-    expect(alias.name, isNotNull);
-    expect(alias.name.name, 'F');
-    expect(alias.typeParameters.typeParameters, hasLength(3));
-    TypeParameter typeParam = alias.typeParameters.typeParameters[2];
-    NamedType type = typeParam.bound;
-    expect(type.typeArguments.arguments, hasLength(3));
-    expect(alias.equals, isNotNull);
-    expect(alias.functionType, isNotNull);
-    expect(alias.semicolon, isNotNull);
-  }
-
-  void test_parseGenericTypeAlias_typeParameters_extends_gtGtEq() {
-    // The scanner creates a single token for `>>=`
-    // then the parser must split it into three separate tokens.
-    createParser('typedef F<A,B,C extends D<E>>=Function(A a, B b, C c);');
-    GenericTypeAlias alias = parseFullCompilationUnitMember();
-    expect(alias, isNotNull);
-    assertNoErrors();
-    expect(alias.name, isNotNull);
-    expect(alias.name.name, 'F');
-    expect(alias.typeParameters.typeParameters, hasLength(3));
-    TypeParameter typeParam = alias.typeParameters.typeParameters[2];
-    NamedType type = typeParam.bound;
-    expect(type.typeArguments.arguments, hasLength(1));
-    expect(alias.equals, isNotNull);
-    expect(alias.functionType, isNotNull);
-    expect(alias.semicolon, isNotNull);
-  }
-
-  void test_parseImportDirective_configuration_multiple() {
-    createParser("import 'lib/lib.dart' if (a) 'b.dart' if (c) 'd.dart';");
-    ImportDirective directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive.keyword, isNotNull);
-    expect(directive.uri, isNotNull);
-    expect(directive.configurations, hasLength(2));
-    expectDottedName(directive.configurations[0].name, ['a']);
-    expectDottedName(directive.configurations[1].name, ['c']);
-    expect(directive.deferredKeyword, isNull);
-    expect(directive.asKeyword, isNull);
-    expect(directive.prefix, isNull);
-    expect(directive.combinators, hasLength(0));
-    expect(directive.semicolon, isNotNull);
-  }
-
-  void test_parseImportDirective_configuration_single() {
-    createParser("import 'lib/lib.dart' if (a.b == 'c.dart') '';");
-    ImportDirective directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive.keyword, isNotNull);
-    expect(directive.uri, isNotNull);
-    expect(directive.configurations, hasLength(1));
-    expectDottedName(directive.configurations[0].name, ['a', 'b']);
-    expect(directive.deferredKeyword, isNull);
-    expect(directive.asKeyword, isNull);
-    expect(directive.prefix, isNull);
-    expect(directive.combinators, hasLength(0));
-    expect(directive.semicolon, isNotNull);
-  }
-
-  void test_parseImportDirective_deferred() {
-    createParser("import 'lib/lib.dart' deferred as a;");
-    ImportDirective directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive.keyword, isNotNull);
-    expect(directive.uri, isNotNull);
-    expect(directive.deferredKeyword, isNotNull);
-    expect(directive.asKeyword, isNotNull);
-    expect(directive.prefix, isNotNull);
-    expect(directive.combinators, hasLength(0));
-    expect(directive.semicolon, isNotNull);
-  }
-
-  void test_parseImportDirective_hide() {
-    createParser("import 'lib/lib.dart' hide A, B;");
-    ImportDirective directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive.keyword, isNotNull);
-    expect(directive.uri, isNotNull);
-    expect(directive.deferredKeyword, isNull);
-    expect(directive.asKeyword, isNull);
-    expect(directive.prefix, isNull);
-    expect(directive.combinators, hasLength(1));
-    expect(directive.semicolon, isNotNull);
-  }
-
-  void test_parseImportDirective_noCombinator() {
-    createParser("import 'lib/lib.dart';");
-    ImportDirective directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive.keyword, isNotNull);
-    expect(directive.uri, isNotNull);
-    expect(directive.deferredKeyword, isNull);
-    expect(directive.asKeyword, isNull);
-    expect(directive.prefix, isNull);
-    expect(directive.combinators, hasLength(0));
-    expect(directive.semicolon, isNotNull);
-  }
-
-  void test_parseImportDirective_prefix() {
-    createParser("import 'lib/lib.dart' as a;");
-    ImportDirective directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive.keyword, isNotNull);
-    expect(directive.uri, isNotNull);
-    expect(directive.deferredKeyword, isNull);
-    expect(directive.asKeyword, isNotNull);
-    expect(directive.prefix, isNotNull);
-    expect(directive.combinators, hasLength(0));
-    expect(directive.semicolon, isNotNull);
-  }
-
-  void test_parseImportDirective_prefix_hide_show() {
-    createParser("import 'lib/lib.dart' as a hide A show B;");
-    ImportDirective directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive.keyword, isNotNull);
-    expect(directive.uri, isNotNull);
-    expect(directive.deferredKeyword, isNull);
-    expect(directive.asKeyword, isNotNull);
-    expect(directive.prefix, isNotNull);
-    expect(directive.combinators, hasLength(2));
-    expect(directive.semicolon, isNotNull);
-  }
-
-  void test_parseImportDirective_prefix_show_hide() {
-    createParser("import 'lib/lib.dart' as a show B hide A;");
-    ImportDirective directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive.keyword, isNotNull);
-    expect(directive.uri, isNotNull);
-    expect(directive.deferredKeyword, isNull);
-    expect(directive.asKeyword, isNotNull);
-    expect(directive.prefix, isNotNull);
-    expect(directive.combinators, hasLength(2));
-    expect(directive.semicolon, isNotNull);
-  }
-
-  void test_parseImportDirective_show() {
-    createParser("import 'lib/lib.dart' show A, B;");
-    ImportDirective directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive.keyword, isNotNull);
-    expect(directive.uri, isNotNull);
-    expect(directive.deferredKeyword, isNull);
-    expect(directive.asKeyword, isNull);
-    expect(directive.prefix, isNull);
-    expect(directive.combinators, hasLength(1));
-    expect(directive.semicolon, isNotNull);
-  }
-
-  void test_parseLibraryDirective() {
-    createParser('library l;');
-    LibraryDirective directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive.libraryKeyword, isNotNull);
-    expect(directive.name, isNotNull);
-    expect(directive.semicolon, isNotNull);
-  }
-
-  void test_parsePartDirective() {
-    createParser("part 'lib/lib.dart';");
-    PartDirective directive = parseFullDirective();
-    expect(directive, isNotNull);
-    assertNoErrors();
-    expect(directive.partKeyword, isNotNull);
-    expect(directive.uri, isNotNull);
-    expect(directive.semicolon, isNotNull);
-  }
-
-  void test_parsePartOfDirective_name() {
-    enableUriInPartOf = true;
-    createParser("part of l;");
-    PartOfDirective directive = parseFullDirective();
-    expect(directive.partKeyword, isNotNull);
-    expect(directive.ofKeyword, isNotNull);
-    expect(directive.libraryName, isNotNull);
-    expect(directive.uri, isNull);
-    expect(directive.semicolon, isNotNull);
-  }
-
-  void test_parsePartOfDirective_uri() {
-    enableUriInPartOf = true;
-    createParser("part of 'lib.dart';");
-    PartOfDirective directive = parseFullDirective();
-    expect(directive.partKeyword, isNotNull);
-    expect(directive.ofKeyword, isNotNull);
-    expect(directive.libraryName, isNull);
-    expect(directive.uri, isNotNull);
-    expect(directive.semicolon, isNotNull);
-  }
-
-  void test_parseTypeAlias_function_noParameters() {
-    createParser('typedef bool F();');
-    FunctionTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expect(typeAlias, isNotNull);
-    assertNoErrors();
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name, isNotNull);
-    expect(typeAlias.parameters, isNotNull);
-    expect(typeAlias.returnType, isNotNull);
-    expect(typeAlias.semicolon, isNotNull);
-    expect(typeAlias.typeParameters, isNull);
-  }
-
-  void test_parseTypeAlias_function_noReturnType() {
-    createParser('typedef F();');
-    FunctionTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expect(typeAlias, isNotNull);
-    assertNoErrors();
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name, isNotNull);
-    expect(typeAlias.parameters, isNotNull);
-    expect(typeAlias.returnType, isNull);
-    expect(typeAlias.semicolon, isNotNull);
-    expect(typeAlias.typeParameters, isNull);
-  }
-
-  void test_parseTypeAlias_function_parameterizedReturnType() {
-    createParser('typedef A<B> F();');
-    FunctionTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expect(typeAlias, isNotNull);
-    assertNoErrors();
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name, isNotNull);
-    expect(typeAlias.parameters, isNotNull);
-    expect(typeAlias.returnType, isNotNull);
-    expect(typeAlias.semicolon, isNotNull);
-    expect(typeAlias.typeParameters, isNull);
-  }
-
-  void test_parseTypeAlias_function_parameters() {
-    createParser('typedef bool F(Object value);');
-    FunctionTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expect(typeAlias, isNotNull);
-    assertNoErrors();
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name, isNotNull);
-    expect(typeAlias.parameters, isNotNull);
-    expect(typeAlias.returnType, isNotNull);
-    expect(typeAlias.semicolon, isNotNull);
-    expect(typeAlias.typeParameters, isNull);
-  }
-
-  void test_parseTypeAlias_function_typeParameters() {
-    createParser('typedef bool F<E>();');
-    FunctionTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expect(typeAlias, isNotNull);
-    assertNoErrors();
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name, isNotNull);
-    expect(typeAlias.parameters, isNotNull);
-    expect(typeAlias.returnType, isNotNull);
-    expect(typeAlias.semicolon, isNotNull);
-    expect(typeAlias.typeParameters, isNotNull);
-  }
-
-  void test_parseTypeAlias_function_voidReturnType() {
-    createParser('typedef void F();');
-    FunctionTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expect(typeAlias, isNotNull);
-    assertNoErrors();
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name, isNotNull);
-    expect(typeAlias.parameters, isNotNull);
-    expect(typeAlias.returnType, isNotNull);
-    expect(typeAlias.semicolon, isNotNull);
-    expect(typeAlias.typeParameters, isNull);
-  }
-
-  void test_parseTypeAlias_genericFunction_noParameters() {
-    createParser('typedef F = bool Function();');
-    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expect(typeAlias, isNotNull);
-    assertNoErrors();
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name, isNotNull);
-    expect(typeAlias.typeParameters, isNull);
-    expect(typeAlias.semicolon, isNotNull);
-    GenericFunctionType functionType = typeAlias.functionType;
-    expect(functionType, isNotNull);
-    expect(functionType.parameters, isNotNull);
-    expect(functionType.returnType, isNotNull);
-    expect(functionType.typeParameters, isNull);
-  }
-
-  void test_parseTypeAlias_genericFunction_noReturnType() {
-    createParser('typedef F = Function();');
-    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expect(typeAlias, isNotNull);
-    assertNoErrors();
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name, isNotNull);
-    expect(typeAlias.typeParameters, isNull);
-    expect(typeAlias.semicolon, isNotNull);
-    GenericFunctionType functionType = typeAlias.functionType;
-    expect(functionType, isNotNull);
-    expect(functionType.parameters, isNotNull);
-    expect(functionType.returnType, isNull);
-    expect(functionType.typeParameters, isNull);
-  }
-
-  void test_parseTypeAlias_genericFunction_parameterizedReturnType() {
-    createParser('typedef F = A<B> Function();');
-    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expect(typeAlias, isNotNull);
-    assertNoErrors();
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name, isNotNull);
-    expect(typeAlias.typeParameters, isNull);
-    expect(typeAlias.semicolon, isNotNull);
-    GenericFunctionType functionType = typeAlias.functionType;
-    expect(functionType, isNotNull);
-    expect(functionType.parameters, isNotNull);
-    expect(functionType.returnType, isNotNull);
-    expect(functionType.typeParameters, isNull);
-  }
-
-  void test_parseTypeAlias_genericFunction_parameters() {
-    createParser('typedef F = bool Function(Object value);');
-    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expect(typeAlias, isNotNull);
-    assertNoErrors();
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name, isNotNull);
-    expect(typeAlias.typeParameters, isNull);
-    expect(typeAlias.semicolon, isNotNull);
-    GenericFunctionType functionType = typeAlias.functionType;
-    expect(functionType, isNotNull);
-    expect(functionType.parameters, isNotNull);
-    expect(functionType.returnType, isNotNull);
-    expect(functionType.typeParameters, isNull);
-  }
-
-  void test_parseTypeAlias_genericFunction_typeParameters() {
-    createParser('typedef F = bool Function<E>();');
-    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expect(typeAlias, isNotNull);
-    assertNoErrors();
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name, isNotNull);
-    expect(typeAlias.typeParameters, isNull);
-    expect(typeAlias.semicolon, isNotNull);
-    GenericFunctionType functionType = typeAlias.functionType;
-    expect(functionType, isNotNull);
-    expect(functionType.parameters, isNotNull);
-    expect(functionType.returnType, isNotNull);
-    expect(functionType.typeParameters, isNotNull);
-  }
-
-  void test_parseTypeAlias_genericFunction_typeParameters_noParameters() {
-    createParser('typedef F<T> = bool Function();');
-    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expect(typeAlias, isNotNull);
-    assertNoErrors();
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name, isNotNull);
-    expect(typeAlias.typeParameters, isNotNull);
-    expect(typeAlias.semicolon, isNotNull);
-    GenericFunctionType functionType = typeAlias.functionType;
-    expect(functionType, isNotNull);
-    expect(functionType.parameters, isNotNull);
-    expect(functionType.returnType, isNotNull);
-    expect(functionType.typeParameters, isNull);
-  }
-
-  void test_parseTypeAlias_genericFunction_typeParameters_noReturnType() {
-    createParser('typedef F<T> = Function();');
-    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expect(typeAlias, isNotNull);
-    assertNoErrors();
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name, isNotNull);
-    expect(typeAlias.typeParameters, isNotNull);
-    expect(typeAlias.semicolon, isNotNull);
-    GenericFunctionType functionType = typeAlias.functionType;
-    expect(functionType, isNotNull);
-    expect(functionType.parameters, isNotNull);
-    expect(functionType.returnType, isNull);
-    expect(functionType.typeParameters, isNull);
-  }
-
-  void
-      test_parseTypeAlias_genericFunction_typeParameters_parameterizedReturnType() {
-    createParser('typedef F<T> = A<B> Function();');
-    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expect(typeAlias, isNotNull);
-    assertNoErrors();
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name, isNotNull);
-    expect(typeAlias.typeParameters, isNotNull);
-    expect(typeAlias.semicolon, isNotNull);
-    GenericFunctionType functionType = typeAlias.functionType;
-    expect(functionType, isNotNull);
-    expect(functionType.parameters, isNotNull);
-    expect(functionType.returnType, isNotNull);
-    expect(functionType.typeParameters, isNull);
-  }
-
-  void test_parseTypeAlias_genericFunction_typeParameters_parameters() {
-    createParser('typedef F<T> = bool Function(Object value);');
-    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expect(typeAlias, isNotNull);
-    assertNoErrors();
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name, isNotNull);
-    expect(typeAlias.typeParameters, isNotNull);
-    expect(typeAlias.semicolon, isNotNull);
-    GenericFunctionType functionType = typeAlias.functionType;
-    expect(functionType, isNotNull);
-    expect(functionType.parameters, isNotNull);
-    expect(functionType.returnType, isNotNull);
-    expect(functionType.typeParameters, isNull);
-  }
-
-  void test_parseTypeAlias_genericFunction_typeParameters_typeParameters() {
-    createParser('typedef F<T> = bool Function<E>();');
-    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expect(typeAlias, isNotNull);
-    assertNoErrors();
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name, isNotNull);
-    expect(typeAlias.typeParameters, isNotNull);
-    expect(typeAlias.semicolon, isNotNull);
-    GenericFunctionType functionType = typeAlias.functionType;
-    expect(functionType, isNotNull);
-    expect(functionType.parameters, isNotNull);
-    expect(functionType.returnType, isNotNull);
-    expect(functionType.typeParameters, isNotNull);
-  }
-
-  void test_parseTypeAlias_genericFunction_typeParameters_voidReturnType() {
-    createParser('typedef F<T> = void Function();');
-    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expect(typeAlias, isNotNull);
-    assertNoErrors();
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name, isNotNull);
-    expect(typeAlias.typeParameters, isNotNull);
-    expect(typeAlias.semicolon, isNotNull);
-    GenericFunctionType functionType = typeAlias.functionType;
-    expect(functionType, isNotNull);
-    expect(functionType.parameters, isNotNull);
-    expect(functionType.returnType, isNotNull);
-    expect(functionType.typeParameters, isNull);
-  }
-
-  void test_parseTypeAlias_genericFunction_voidReturnType() {
-    createParser('typedef F = void Function();');
-    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
-    expect(typeAlias, isNotNull);
-    assertNoErrors();
-    expect(typeAlias.typedefKeyword, isNotNull);
-    expect(typeAlias.name, isNotNull);
-    expect(typeAlias.typeParameters, isNull);
-    expect(typeAlias.semicolon, isNotNull);
-    GenericFunctionType functionType = typeAlias.functionType;
-    expect(functionType, isNotNull);
-    expect(functionType.parameters, isNotNull);
-    expect(functionType.returnType, isNotNull);
-    expect(functionType.typeParameters, isNull);
-  }
-
-  void test_parseTypeAlias_genericFunction_withDocComment() {
-    createParser('/// Doc\ntypedef F = bool Function();');
-    var typeAlias = parseFullCompilationUnitMember() as GenericTypeAlias;
-    expectCommentText(typeAlias.documentationComment, '/// Doc');
-  }
-
-  void test_parseTypeVariable_withDocumentationComment() {
-    createParser('''
-class A<
-    /// Doc
-    B> {}
-''');
-    var classDeclaration = parseFullCompilationUnitMember() as ClassDeclaration;
-    var typeVariable = classDeclaration.typeParameters.typeParameters[0];
-    expectCommentText(typeVariable.documentationComment, '/// Doc');
-  }
-
-  /// Assert that the given [name] is in declaration context.
-  void _assertIsDeclarationName(SimpleIdentifier name) {
-    expect(name.inDeclarationContext(), isTrue);
-  }
-}
diff --git a/pkg/analyzer/test/generated/recovery_parser_test.dart b/pkg/analyzer/test/generated/recovery_parser_test.dart
new file mode 100644
index 0000000..b578737
--- /dev/null
+++ b/pkg/analyzer/test/generated/recovery_parser_test.dart
@@ -0,0 +1,1518 @@
+// Copyright (c) 2020, 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.
+
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/src/dart/scanner/scanner.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../util/ast_type_matchers.dart';
+import 'parser_test_base.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(RecoveryParserTest);
+  });
+}
+
+/// The class `RecoveryParserTest` defines parser tests that test the parsing of
+/// invalid code sequences to ensure that the correct recovery steps are taken
+/// in the parser.
+@reflectiveTest
+class RecoveryParserTest extends FastaParserTestCase {
+  void test_additiveExpression_missing_LHS() {
+    BinaryExpression expression =
+        parseExpression("+ y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.leftOperand, isSimpleIdentifier);
+    expect(expression.leftOperand.isSynthetic, isTrue);
+  }
+
+  void test_additiveExpression_missing_LHS_RHS() {
+    BinaryExpression expression = parseExpression("+", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isSimpleIdentifier);
+    expect(expression.leftOperand.isSynthetic, isTrue);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_additiveExpression_missing_RHS() {
+    BinaryExpression expression =
+        parseExpression("x +", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_additiveExpression_missing_RHS_super() {
+    BinaryExpression expression =
+        parseExpression("super +", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_additiveExpression_precedence_multiplicative_left() {
+    BinaryExpression expression = parseExpression("* +", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_additiveExpression_precedence_multiplicative_right() {
+    BinaryExpression expression = parseExpression("+ *", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.rightOperand, isBinaryExpression);
+  }
+
+  void test_additiveExpression_super() {
+    BinaryExpression expression = parseExpression("super + +", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_assignableSelector() {
+    IndexExpression expression =
+        parseExpression("a.b[]", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    Expression index = expression.index;
+    expect(index, isSimpleIdentifier);
+    expect(index.isSynthetic, isTrue);
+  }
+
+  void test_assignmentExpression_missing_compound1() {
+    AssignmentExpression expression =
+        parseExpression("= y = 0", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    Expression syntheticExpression = expression.leftHandSide;
+    expect(syntheticExpression, isSimpleIdentifier);
+    expect(syntheticExpression.isSynthetic, isTrue);
+  }
+
+  void test_assignmentExpression_missing_compound2() {
+    AssignmentExpression expression =
+        parseExpression("x = = 0", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    Expression syntheticExpression =
+        (expression.rightHandSide as AssignmentExpression).leftHandSide;
+    expect(syntheticExpression, isSimpleIdentifier);
+    expect(syntheticExpression.isSynthetic, isTrue);
+  }
+
+  void test_assignmentExpression_missing_compound3() {
+    AssignmentExpression expression =
+        parseExpression("x = y =", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    Expression syntheticExpression =
+        (expression.rightHandSide as AssignmentExpression).rightHandSide;
+    expect(syntheticExpression, isSimpleIdentifier);
+    expect(syntheticExpression.isSynthetic, isTrue);
+  }
+
+  void test_assignmentExpression_missing_LHS() {
+    AssignmentExpression expression =
+        parseExpression("= 0", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.leftHandSide, isSimpleIdentifier);
+    expect(expression.leftHandSide.isSynthetic, isTrue);
+  }
+
+  void test_assignmentExpression_missing_RHS() {
+    AssignmentExpression expression =
+        parseExpression("x =", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.leftHandSide, isSimpleIdentifier);
+    expect(expression.rightHandSide.isSynthetic, isTrue);
+  }
+
+  void test_bitwiseAndExpression_missing_LHS() {
+    BinaryExpression expression =
+        parseExpression("& y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.leftOperand, isSimpleIdentifier);
+    expect(expression.leftOperand.isSynthetic, isTrue);
+  }
+
+  void test_bitwiseAndExpression_missing_LHS_RHS() {
+    BinaryExpression expression = parseExpression("&", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isSimpleIdentifier);
+    expect(expression.leftOperand.isSynthetic, isTrue);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_bitwiseAndExpression_missing_RHS() {
+    BinaryExpression expression =
+        parseExpression("x &", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_bitwiseAndExpression_missing_RHS_super() {
+    BinaryExpression expression =
+        parseExpression("super &", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_bitwiseAndExpression_precedence_equality_left() {
+    BinaryExpression expression = parseExpression("== &&", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_bitwiseAndExpression_precedence_equality_right() {
+    BinaryExpression expression = parseExpression("&& ==", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.rightOperand, isBinaryExpression);
+  }
+
+  void test_bitwiseAndExpression_super() {
+    BinaryExpression expression = parseExpression("super &  &", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_bitwiseOrExpression_missing_LHS() {
+    BinaryExpression expression =
+        parseExpression("| y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.leftOperand, isSimpleIdentifier);
+    expect(expression.leftOperand.isSynthetic, isTrue);
+  }
+
+  void test_bitwiseOrExpression_missing_LHS_RHS() {
+    BinaryExpression expression = parseExpression("|", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isSimpleIdentifier);
+    expect(expression.leftOperand.isSynthetic, isTrue);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_bitwiseOrExpression_missing_RHS() {
+    BinaryExpression expression =
+        parseExpression("x |", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_bitwiseOrExpression_missing_RHS_super() {
+    BinaryExpression expression =
+        parseExpression("super |", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_bitwiseOrExpression_precedence_xor_left() {
+    BinaryExpression expression = parseExpression("^ |", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_bitwiseOrExpression_precedence_xor_right() {
+    BinaryExpression expression = parseExpression("| ^", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.rightOperand, isBinaryExpression);
+  }
+
+  void test_bitwiseOrExpression_super() {
+    BinaryExpression expression = parseExpression("super |  |", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_bitwiseXorExpression_missing_LHS() {
+    BinaryExpression expression =
+        parseExpression("^ y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.leftOperand, isSimpleIdentifier);
+    expect(expression.leftOperand.isSynthetic, isTrue);
+  }
+
+  void test_bitwiseXorExpression_missing_LHS_RHS() {
+    BinaryExpression expression = parseExpression("^", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isSimpleIdentifier);
+    expect(expression.leftOperand.isSynthetic, isTrue);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_bitwiseXorExpression_missing_RHS() {
+    BinaryExpression expression =
+        parseExpression("x ^", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_bitwiseXorExpression_missing_RHS_super() {
+    BinaryExpression expression =
+        parseExpression("super ^", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_bitwiseXorExpression_precedence_and_left() {
+    BinaryExpression expression = parseExpression("& ^", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_bitwiseXorExpression_precedence_and_right() {
+    BinaryExpression expression = parseExpression("^ &", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.rightOperand, isBinaryExpression);
+  }
+
+  void test_bitwiseXorExpression_super() {
+    BinaryExpression expression = parseExpression("super ^  ^", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_classTypeAlias_withBody() {
+    parseCompilationUnit(r'''
+class A {}
+class B = Object with A {}''', codes:
+// TODO(danrubel): Consolidate and improve error message.
+            [
+      ParserErrorCode.EXPECTED_EXECUTABLE,
+      ParserErrorCode.EXPECTED_TOKEN
+    ]);
+  }
+
+  void test_combinator_badIdentifier() {
+    createParser('import "/testB.dart" show @');
+    parser.parseCompilationUnit2();
+    listener.assertErrors([
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 26, 1),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 27, 0),
+      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 27, 0),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 27, 0)
+    ]);
+  }
+
+  void test_combinator_missingIdentifier() {
+    createParser('import "/testB.dart" show ;');
+    parser.parseCompilationUnit2();
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 26, 1)]);
+  }
+
+  void test_conditionalExpression_missingElse() {
+    Expression expression =
+        parseExpression('x ? y :', codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expectNotNullIfNoErrors(expression);
+    expect(expression, isConditionalExpression);
+    ConditionalExpression conditionalExpression = expression;
+    expect(conditionalExpression.elseExpression, isSimpleIdentifier);
+    expect(conditionalExpression.elseExpression.isSynthetic, isTrue);
+  }
+
+  void test_conditionalExpression_missingThen() {
+    Expression expression =
+        parseExpression('x ? : z', codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expectNotNullIfNoErrors(expression);
+    expect(expression, isConditionalExpression);
+    ConditionalExpression conditionalExpression = expression;
+    expect(conditionalExpression.thenExpression, isSimpleIdentifier);
+    expect(conditionalExpression.thenExpression.isSynthetic, isTrue);
+  }
+
+  void test_conditionalExpression_super() {
+    parseExpression('x ? super : z', errors: [
+      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 4, 5)
+    ]);
+  }
+
+  void test_conditionalExpression_super2() {
+    parseExpression('x ? z : super', errors: [
+      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 8, 5)
+    ]);
+  }
+
+  void test_declarationBeforeDirective() {
+    CompilationUnit unit = parseCompilationUnit(
+        "class foo { } import 'bar.dart';",
+        codes: [ParserErrorCode.DIRECTIVE_AFTER_DECLARATION]);
+    expect(unit.directives, hasLength(1));
+    expect(unit.declarations, hasLength(1));
+    ClassDeclaration classDecl = unit.childEntities.first;
+    expect(classDecl, isNotNull);
+    expect(classDecl.name.name, 'foo');
+  }
+
+  void test_equalityExpression_missing_LHS() {
+    BinaryExpression expression =
+        parseExpression("== y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.leftOperand, isSimpleIdentifier);
+    expect(expression.leftOperand.isSynthetic, isTrue);
+  }
+
+  void test_equalityExpression_missing_LHS_RHS() {
+    BinaryExpression expression = parseExpression("==", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isSimpleIdentifier);
+    expect(expression.leftOperand.isSynthetic, isTrue);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_equalityExpression_missing_RHS() {
+    BinaryExpression expression =
+        parseExpression("x ==", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_equalityExpression_missing_RHS_super() {
+    BinaryExpression expression = parseExpression("super ==",
+        codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_equalityExpression_precedence_relational_right() {
+    parseExpression("== is", codes: [
+      ParserErrorCode.EXPECTED_TYPE_NAME,
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+  }
+
+  void test_equalityExpression_super() {
+    BinaryExpression expression = parseExpression("super ==  ==", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND
+    ]);
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_equalityExpression_superRHS() {
+    parseExpression("1 == super", errors: [
+      expectedError(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 5, 5)
+    ]);
+  }
+
+  void test_expressionList_multiple_end() {
+    List<Expression> result = parseExpressionList(', 2, 3, 4');
+    expectNotNullIfNoErrors(result);
+// TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
+    listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
+//    listener.assertErrors(
+//        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 0, 1)]);
+    expect(result, hasLength(4));
+    Expression syntheticExpression = result[0];
+    expect(syntheticExpression, isSimpleIdentifier);
+    expect(syntheticExpression.isSynthetic, isTrue);
+  }
+
+  void test_expressionList_multiple_middle() {
+    List<Expression> result = parseExpressionList('1, 2, , 4');
+    expectNotNullIfNoErrors(result);
+// TODO(brianwilkerson) Convert codes to errors when highlighting is fixed.
+    listener.assertErrorsWithCodes([ParserErrorCode.MISSING_IDENTIFIER]);
+//    listener.assertErrors(
+//        [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 1)]);
+    expect(result, hasLength(4));
+    Expression syntheticExpression = result[2];
+    expect(syntheticExpression, isSimpleIdentifier);
+    expect(syntheticExpression.isSynthetic, isTrue);
+  }
+
+  void test_expressionList_multiple_start() {
+    List<Expression> result = parseExpressionList('1, 2, 3,');
+    expectNotNullIfNoErrors(result);
+// The fasta parser does not use parseExpressionList when parsing for loops
+// and instead parseExpressionList is mapped to parseExpression('[$code]')
+// which allows and ignores an optional trailing comma.
+    assertNoErrors();
+    expect(result, hasLength(3));
+  }
+
+  void test_functionExpression_in_ConstructorFieldInitializer() {
+    CompilationUnit unit =
+        parseCompilationUnit("class A { A() : a = (){}; var v; }", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.EXPECTED_CLASS_MEMBER
+    ]);
+// Make sure we recovered and parsed "var v" correctly
+    ClassDeclaration declaration = unit.declarations[0] as ClassDeclaration;
+    NodeList<ClassMember> members = declaration.members;
+    ClassMember fieldDecl = members[1];
+    expect(fieldDecl, isFieldDeclaration);
+    NodeList<VariableDeclaration> vars =
+        (fieldDecl as FieldDeclaration).fields.variables;
+    expect(vars, hasLength(1));
+    expect(vars[0].name.name, "v");
+  }
+
+  void test_functionExpression_named() {
+    parseExpression("m(f() => 0);",
+        expectedEndOffset: 11,
+        codes: [ParserErrorCode.NAMED_FUNCTION_EXPRESSION]);
+  }
+
+  void test_ifStatement_noElse_statement() {
+    parseStatement('if (x v) f(x);');
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 6, 1)]);
+  }
+
+  void test_importDirectivePartial_as() {
+    CompilationUnit unit = parseCompilationUnit("import 'b.dart' d as b;",
+        codes: [ParserErrorCode.UNEXPECTED_TOKEN]);
+    ImportDirective importDirective = unit.childEntities.first;
+    expect(importDirective.asKeyword, isNotNull);
+    expect(unit.directives, hasLength(1));
+    expect(unit.declarations, hasLength(0));
+  }
+
+  void test_importDirectivePartial_hide() {
+    CompilationUnit unit = parseCompilationUnit("import 'b.dart' d hide foo;",
+        codes: [ParserErrorCode.UNEXPECTED_TOKEN]);
+    ImportDirective importDirective = unit.childEntities.first;
+    expect(importDirective.combinators, hasLength(1));
+    expect(unit.directives, hasLength(1));
+    expect(unit.declarations, hasLength(0));
+  }
+
+  void test_importDirectivePartial_show() {
+    CompilationUnit unit = parseCompilationUnit("import 'b.dart' d show foo;",
+        codes: [ParserErrorCode.UNEXPECTED_TOKEN]);
+    ImportDirective importDirective = unit.childEntities.first;
+    expect(importDirective.combinators, hasLength(1));
+    expect(unit.directives, hasLength(1));
+    expect(unit.declarations, hasLength(0));
+  }
+
+  void test_incomplete_conditionalExpression() {
+    parseExpression("x ? 0", codes: [
+      ParserErrorCode.EXPECTED_TOKEN,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+  }
+
+  void test_incomplete_constructorInitializers_empty() {
+    createParser('C() : {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.MISSING_INITIALIZER, 4, 1)]);
+  }
+
+  void test_incomplete_constructorInitializers_missingEquals() {
+    createParser('C() : x(3) {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 6, 1)
+    ]);
+    expect(member, isConstructorDeclaration);
+    NodeList<ConstructorInitializer> initializers =
+        (member as ConstructorDeclaration).initializers;
+    expect(initializers, hasLength(1));
+    ConstructorInitializer initializer = initializers[0];
+    expect(initializer, isConstructorFieldInitializer);
+    Expression expression =
+        (initializer as ConstructorFieldInitializer).expression;
+    expect(expression, isNotNull);
+    expect(expression, isMethodInvocation);
+  }
+
+  void test_incomplete_constructorInitializers_this() {
+    createParser('C() : this {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 11, 1),
+      expectedError(ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 6, 4)
+    ]);
+  }
+
+  void test_incomplete_constructorInitializers_thisField() {
+    createParser('C() : this.g {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 6, 4)
+    ]);
+  }
+
+  void test_incomplete_constructorInitializers_thisPeriod() {
+    createParser('C() : this. {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 12, 1),
+      expectedError(ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 6, 4)
+    ]);
+  }
+
+  void test_incomplete_constructorInitializers_variable() {
+    createParser('C() : x {}');
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 6, 1)
+    ]);
+  }
+
+  void test_incomplete_functionExpression() {
+    var expression = parseExpression("() a => null",
+        errors: [expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 3, 1)]);
+    FunctionExpression functionExpression = expression;
+    expect(functionExpression.parameters.parameters, hasLength(0));
+  }
+
+  void test_incomplete_functionExpression2() {
+    var expression = parseExpression("() a {}",
+        errors: [expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 3, 1)]);
+    FunctionExpression functionExpression = expression;
+    expect(functionExpression.parameters.parameters, hasLength(0));
+  }
+
+  void test_incomplete_returnType() {
+    parseCompilationUnit(r'''
+Map<Symbol, convertStringToSymbolMap(Map<String, dynamic> map) {
+  if (map == null) return null;
+  Map<Symbol, dynamic> result = new Map<Symbol, dynamic>();
+  map.forEach((name, value) {
+    result[new Symbol(name)] = value;
+  });
+  return result;
+}''', errors: [
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 12, 24),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 0, 3)
+    ]);
+  }
+
+  void test_incomplete_topLevelFunction() {
+    parseCompilationUnit("foo();",
+        codes: [ParserErrorCode.MISSING_FUNCTION_BODY]);
+  }
+
+  void test_incomplete_topLevelVariable() {
+    CompilationUnit unit = parseCompilationUnit("String", errors: [
+      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 0, 6),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 0, 6)
+    ]);
+    NodeList<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(1));
+    CompilationUnitMember member = declarations[0];
+    expect(member, isTopLevelVariableDeclaration);
+    NodeList<VariableDeclaration> variables =
+        (member as TopLevelVariableDeclaration).variables.variables;
+    expect(variables, hasLength(1));
+    SimpleIdentifier name = variables[0].name;
+    expect(name.isSynthetic, isFalse);
+  }
+
+  void test_incomplete_topLevelVariable_const() {
+    CompilationUnit unit = parseCompilationUnit("const ", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.EXPECTED_TOKEN
+    ]);
+    NodeList<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(1));
+    CompilationUnitMember member = declarations[0];
+    expect(member, isTopLevelVariableDeclaration);
+    NodeList<VariableDeclaration> variables =
+        (member as TopLevelVariableDeclaration).variables.variables;
+    expect(variables, hasLength(1));
+    SimpleIdentifier name = variables[0].name;
+    expect(name.isSynthetic, isTrue);
+  }
+
+  void test_incomplete_topLevelVariable_final() {
+    CompilationUnit unit = parseCompilationUnit("final ", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.EXPECTED_TOKEN
+    ]);
+    NodeList<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(1));
+    CompilationUnitMember member = declarations[0];
+    expect(member, isTopLevelVariableDeclaration);
+    NodeList<VariableDeclaration> variables =
+        (member as TopLevelVariableDeclaration).variables.variables;
+    expect(variables, hasLength(1));
+    SimpleIdentifier name = variables[0].name;
+    expect(name.isSynthetic, isTrue);
+  }
+
+  void test_incomplete_topLevelVariable_var() {
+    CompilationUnit unit = parseCompilationUnit("var ", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.EXPECTED_TOKEN
+    ]);
+    NodeList<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(1));
+    CompilationUnitMember member = declarations[0];
+    expect(member, isTopLevelVariableDeclaration);
+    NodeList<VariableDeclaration> variables =
+        (member as TopLevelVariableDeclaration).variables.variables;
+    expect(variables, hasLength(1));
+    SimpleIdentifier name = variables[0].name;
+    expect(name.isSynthetic, isTrue);
+  }
+
+  void test_incompleteField_const() {
+    CompilationUnit unit = parseCompilationUnit(r'''
+class C {
+  const
+}''', codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.EXPECTED_TOKEN
+    ]);
+    NodeList<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(1));
+    CompilationUnitMember unitMember = declarations[0];
+    expect(unitMember, isClassDeclaration);
+    NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
+    expect(members, hasLength(1));
+    ClassMember classMember = members[0];
+    expect(classMember, isFieldDeclaration);
+    VariableDeclarationList fieldList =
+        (classMember as FieldDeclaration).fields;
+    expect(fieldList.keyword.keyword, Keyword.CONST);
+    NodeList<VariableDeclaration> fields = fieldList.variables;
+    expect(fields, hasLength(1));
+    VariableDeclaration field = fields[0];
+    expect(field.name.isSynthetic, isTrue);
+  }
+
+  void test_incompleteField_final() {
+    CompilationUnit unit = parseCompilationUnit(r'''
+class C {
+  final
+}''', codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.EXPECTED_TOKEN
+    ]);
+    NodeList<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(1));
+    CompilationUnitMember unitMember = declarations[0];
+    expect(unitMember, isClassDeclaration);
+    NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
+    expect(members, hasLength(1));
+    ClassMember classMember = members[0];
+    expect(classMember, isFieldDeclaration);
+    VariableDeclarationList fieldList =
+        (classMember as FieldDeclaration).fields;
+    expect(fieldList.keyword.keyword, Keyword.FINAL);
+    NodeList<VariableDeclaration> fields = fieldList.variables;
+    expect(fields, hasLength(1));
+    VariableDeclaration field = fields[0];
+    expect(field.name.isSynthetic, isTrue);
+  }
+
+  void test_incompleteField_static() {
+    CompilationUnit unit = parseCompilationUnit(r'''
+class C {
+  static c
+}''', codes: [
+      ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE,
+      ParserErrorCode.EXPECTED_TOKEN
+    ]);
+    NodeList<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(1));
+    CompilationUnitMember unitMember = declarations[0];
+    expect(unitMember, isClassDeclaration);
+    NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
+    expect(members, hasLength(1));
+    ClassMember classMember = members[0];
+    expect(classMember, isFieldDeclaration);
+    FieldDeclaration declaration = classMember;
+    expect(declaration.staticKeyword.lexeme, 'static');
+    VariableDeclarationList fieldList = declaration.fields;
+    expect(fieldList.keyword, isNull);
+    NodeList<VariableDeclaration> fields = fieldList.variables;
+    expect(fields, hasLength(1));
+    VariableDeclaration field = fields[0];
+    expect(field.name.isSynthetic, isFalse);
+  }
+
+  void test_incompleteField_static2() {
+    CompilationUnit unit = parseCompilationUnit(r'''
+class C {
+  static c x
+}''', codes: [ParserErrorCode.EXPECTED_TOKEN]);
+    NodeList<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(1));
+    CompilationUnitMember unitMember = declarations[0];
+    expect(unitMember, isClassDeclaration);
+    NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
+    expect(members, hasLength(1));
+    ClassMember classMember = members[0];
+    expect(classMember, isFieldDeclaration);
+    FieldDeclaration declaration = classMember;
+    expect(declaration.staticKeyword.lexeme, 'static');
+    VariableDeclarationList fieldList = declaration.fields;
+    expect(fieldList.keyword, isNull);
+    NodeList<VariableDeclaration> fields = fieldList.variables;
+    expect(fields, hasLength(1));
+    VariableDeclaration field = fields[0];
+    expect(field.name.isSynthetic, isFalse);
+  }
+
+  void test_incompleteField_type() {
+    CompilationUnit unit = parseCompilationUnit(r'''
+class C {
+  A
+}''', codes: [
+      ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE,
+      ParserErrorCode.EXPECTED_TOKEN
+    ]);
+    NodeList<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(1));
+    CompilationUnitMember unitMember = declarations[0];
+    expect(unitMember, isClassDeclaration);
+    NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
+    expect(members, hasLength(1));
+    ClassMember classMember = members[0];
+    expect(classMember, isFieldDeclaration);
+    VariableDeclarationList fieldList =
+        (classMember as FieldDeclaration).fields;
+    TypeName type = fieldList.type;
+    NodeList<VariableDeclaration> fields = fieldList.variables;
+    expect(fields, hasLength(1));
+    VariableDeclaration field = fields[0];
+    expect(type, isNull);
+    expect(field.name.name, 'A');
+  }
+
+  void test_incompleteField_var() {
+    CompilationUnit unit = parseCompilationUnit(r'''
+class C {
+  var
+}''', codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.EXPECTED_TOKEN
+    ]);
+    NodeList<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(1));
+    CompilationUnitMember unitMember = declarations[0];
+    expect(unitMember, isClassDeclaration);
+    NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
+    expect(members, hasLength(1));
+    ClassMember classMember = members[0];
+    expect(classMember, isFieldDeclaration);
+    VariableDeclarationList fieldList =
+        (classMember as FieldDeclaration).fields;
+    expect(fieldList.keyword.keyword, Keyword.VAR);
+    NodeList<VariableDeclaration> fields = fieldList.variables;
+    expect(fields, hasLength(1));
+    VariableDeclaration field = fields[0];
+    expect(field.name.isSynthetic, isTrue);
+  }
+
+  void test_incompleteForEach() {
+// TODO(danrubel): remove this once control flow and spread collection
+// entry parsing is enabled by default
+    ForStatement statement = parseStatement('for (String item i) {}');
+    listener.assertErrors([
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 12, 4),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 17, 1)
+    ]);
+    expect(statement, isForStatement);
+    expect(statement.toSource(), 'for (String item; i;) {}');
+    var forParts = statement.forLoopParts as ForParts;
+    expect(forParts.leftSeparator, isNotNull);
+    expect(forParts.leftSeparator.type, TokenType.SEMICOLON);
+    expect(forParts.rightSeparator, isNotNull);
+    expect(forParts.rightSeparator.type, TokenType.SEMICOLON);
+  }
+
+  void test_incompleteForEach2() {
+    ForStatement statement =
+        parseStatement('for (String item i) {}', featureSet: controlFlow);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 12, 4),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 17, 1)
+    ]);
+    expect(statement.toSource(), 'for (String item; i;) {}');
+    ForPartsWithDeclarations forLoopParts = statement.forLoopParts;
+    expect(forLoopParts.leftSeparator, isNotNull);
+    expect(forLoopParts.leftSeparator.type, TokenType.SEMICOLON);
+    expect(forLoopParts.rightSeparator, isNotNull);
+    expect(forLoopParts.rightSeparator.type, TokenType.SEMICOLON);
+  }
+
+  void test_incompleteLocalVariable_atTheEndOfBlock() {
+    Statement statement = parseStatement('String v }', expectedEndOffset: 9);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
+    expect(statement, isVariableDeclarationStatement);
+    expect(statement.toSource(), 'String v;');
+  }
+
+  void test_incompleteLocalVariable_atTheEndOfBlock_modifierOnly() {
+    Statement statement = parseStatement('final }', expectedEndOffset: 6);
+    listener.assertErrors([
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 6, 1),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 6, 1)
+    ]);
+    expect(statement, isVariableDeclarationStatement);
+    expect(statement.toSource(), 'final ;');
+  }
+
+  void test_incompleteLocalVariable_beforeIdentifier() {
+    Statement statement =
+        parseStatement('String v String v2;', expectedEndOffset: 9);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
+    expect(statement, isVariableDeclarationStatement);
+    expect(statement.toSource(), 'String v;');
+  }
+
+  void test_incompleteLocalVariable_beforeKeyword() {
+    Statement statement =
+        parseStatement('String v if (true) {}', expectedEndOffset: 9);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
+    expect(statement, isVariableDeclarationStatement);
+    expect(statement.toSource(), 'String v;');
+  }
+
+  void test_incompleteLocalVariable_beforeNextBlock() {
+    Statement statement = parseStatement('String v {}', expectedEndOffset: 9);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
+    expect(statement, isVariableDeclarationStatement);
+    expect(statement.toSource(), 'String v;');
+  }
+
+  void test_incompleteLocalVariable_parameterizedType() {
+    Statement statement =
+        parseStatement('List<String> v {}', expectedEndOffset: 15);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 13, 1)]);
+    expect(statement, isVariableDeclarationStatement);
+    expect(statement.toSource(), 'List<String> v;');
+  }
+
+  void test_incompleteTypeArguments_field() {
+    CompilationUnit unit = parseCompilationUnit(r'''
+class C {
+  final List<int f;
+}''', errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 23, 3)]);
+// one class
+    List<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(1));
+    ClassDeclaration classDecl = declarations[0] as ClassDeclaration;
+// one field declaration
+    List<ClassMember> members = classDecl.members;
+    expect(members, hasLength(1));
+    FieldDeclaration fieldDecl = members[0] as FieldDeclaration;
+// one field
+    VariableDeclarationList fieldList = fieldDecl.fields;
+    List<VariableDeclaration> fields = fieldList.variables;
+    expect(fields, hasLength(1));
+    VariableDeclaration field = fields[0];
+    expect(field.name.name, 'f');
+// validate the type
+    TypeArgumentList typeArguments = (fieldList.type as TypeName).typeArguments;
+    expect(typeArguments.arguments, hasLength(1));
+// synthetic '>'
+    Token token = typeArguments.endToken;
+    expect(token.type, TokenType.GT);
+    expect(token.isSynthetic, isTrue);
+  }
+
+  void test_incompleteTypeParameters() {
+    CompilationUnit unit = parseCompilationUnit(r'''
+class C<K {
+}''', errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 8, 1)]);
+// one class
+    List<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(1));
+    ClassDeclaration classDecl = declarations[0] as ClassDeclaration;
+// validate the type parameters
+    TypeParameterList typeParameters = classDecl.typeParameters;
+    expect(typeParameters.typeParameters, hasLength(1));
+// synthetic '>'
+    Token token = typeParameters.endToken;
+    expect(token.type, TokenType.GT);
+    expect(token.isSynthetic, isTrue);
+  }
+
+  void test_incompleteTypeParameters2() {
+    CompilationUnit unit = parseCompilationUnit(r'''
+class C<K extends L<T> {
+}''', errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 21, 1)]);
+// one class
+    List<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(1));
+    ClassDeclaration classDecl = declarations[0] as ClassDeclaration;
+// validate the type parameters
+    TypeParameterList typeParameters = classDecl.typeParameters;
+    expect(typeParameters.typeParameters, hasLength(1));
+// synthetic '>'
+    Token token = typeParameters.endToken;
+    expect(token.type, TokenType.GT);
+    expect(token.isSynthetic, isTrue);
+  }
+
+  void test_incompleteTypeParameters3() {
+    CompilationUnit unit = parseCompilationUnit(r'''
+class C<K extends L<T {
+}''', errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 20, 1)]);
+// one class
+    List<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(1));
+    ClassDeclaration classDecl = declarations[0] as ClassDeclaration;
+// validate the type parameters
+    TypeParameterList typeParameters = classDecl.typeParameters;
+    expect(typeParameters.typeParameters, hasLength(1));
+// synthetic '>'
+    Token token = typeParameters.endToken;
+    expect(token.type, TokenType.GT);
+    expect(token.isSynthetic, isTrue);
+  }
+
+  void test_invalidFunctionBodyModifier() {
+    parseCompilationUnit("f() sync {}",
+        codes: [ParserErrorCode.MISSING_STAR_AFTER_SYNC]);
+  }
+
+  void test_invalidMapLiteral() {
+    parseCompilationUnit("class C { var f = Map<A, B> {}; }", codes: [
+// TODO(danrubel): Improve error message to indicate
+// that "Map" should be removed.
+      ParserErrorCode.EXPECTED_TOKEN,
+      ParserErrorCode.MISSING_KEYWORD_OPERATOR,
+      ParserErrorCode.MISSING_METHOD_PARAMETERS,
+      ParserErrorCode.EXPECTED_CLASS_MEMBER,
+    ]);
+  }
+
+  void test_invalidTypeParameters() {
+    CompilationUnit unit = parseCompilationUnit(r'''
+class C {
+  G<int double> g;
+}''', errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 18, 6)]);
+// one class
+    List<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(1));
+// validate members
+    ClassDeclaration classDecl = declarations[0] as ClassDeclaration;
+    expect(classDecl.members, hasLength(1));
+    FieldDeclaration fields = classDecl.members.first;
+    expect(fields.fields.variables, hasLength(1));
+    VariableDeclaration field = fields.fields.variables.first;
+    expect(field.name.name, 'g');
+  }
+
+  void test_invalidTypeParameters_super() {
+    parseCompilationUnit('class C<X super Y> {}', errors: [
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 8, 1),
+    ]);
+  }
+
+  void test_isExpression_noType() {
+    CompilationUnit unit = parseCompilationUnit(
+        "class Bar<T extends Foo> {m(x){if (x is ) return;if (x is !)}}",
+        codes: [
+          ParserErrorCode.EXPECTED_TYPE_NAME,
+          ParserErrorCode.EXPECTED_TYPE_NAME,
+          ParserErrorCode.MISSING_IDENTIFIER,
+          ParserErrorCode.EXPECTED_TOKEN,
+        ]);
+    ClassDeclaration declaration = unit.declarations[0] as ClassDeclaration;
+    MethodDeclaration method = declaration.members[0] as MethodDeclaration;
+    BlockFunctionBody body = method.body as BlockFunctionBody;
+    IfStatement ifStatement = body.block.statements[1] as IfStatement;
+    IsExpression expression = ifStatement.condition as IsExpression;
+    expect(expression.expression, isNotNull);
+    expect(expression.isOperator, isNotNull);
+    expect(expression.notOperator, isNotNull);
+    TypeAnnotation type = expression.type;
+    expect(type, isNotNull);
+    expect(type is TypeName && type.name.isSynthetic, isTrue);
+    ExpressionStatement thenStatement = ifStatement.thenStatement;
+    expect(thenStatement.semicolon.isSynthetic, isTrue);
+    SimpleIdentifier simpleId = thenStatement.expression;
+    expect(simpleId.isSynthetic, isTrue);
+  }
+
+  void test_issue_34610_get() {
+    final unit =
+        parseCompilationUnit('class C { get C.named => null; }', errors: [
+      expectedError(ParserErrorCode.GETTER_CONSTRUCTOR, 10, 3),
+      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 14, 1),
+    ]);
+    ClassDeclaration declaration = unit.declarations[0];
+    ConstructorDeclaration method = declaration.members[0];
+    expect(method.name.name, 'named');
+    expect(method.parameters, isNotNull);
+  }
+
+  void test_issue_34610_initializers() {
+    final unit = parseCompilationUnit('class C { C.named : super(); }',
+        errors: [
+          expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 10, 1)
+        ]);
+    ClassDeclaration declaration = unit.declarations[0];
+    ConstructorDeclaration constructor = declaration.members[0];
+    expect(constructor.name.name, 'named');
+    expect(constructor.parameters, isNotNull);
+    expect(constructor.parameters.parameters, hasLength(0));
+  }
+
+  void test_issue_34610_missing_param() {
+    final unit = parseCompilationUnit('class C { C => null; }', errors: [
+      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 10, 1)
+    ]);
+    ClassDeclaration declaration = unit.declarations[0];
+    ConstructorDeclaration constructor = declaration.members[0];
+    expect(constructor.name, isNull);
+    expect(constructor.parameters, isNotNull);
+    expect(constructor.parameters.parameters, hasLength(0));
+  }
+
+  void test_issue_34610_named_missing_param() {
+    final unit = parseCompilationUnit('class C { C.named => null; }', errors: [
+      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 10, 1)
+    ]);
+    ClassDeclaration declaration = unit.declarations[0];
+    ConstructorDeclaration constructor = declaration.members[0];
+    expect(constructor.name.name, 'named');
+    expect(constructor.parameters, isNotNull);
+    expect(constructor.parameters.parameters, hasLength(0));
+  }
+
+  void test_issue_34610_set() {
+    final unit =
+        parseCompilationUnit('class C { set C.named => null; }', errors: [
+      expectedError(ParserErrorCode.SETTER_CONSTRUCTOR, 10, 3),
+      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 14, 1),
+    ]);
+    ClassDeclaration declaration = unit.declarations[0];
+    ConstructorDeclaration method = declaration.members[0];
+    expect(method.name.name, 'named');
+    expect(method.parameters, isNotNull);
+    expect(method.parameters.parameters, hasLength(0));
+  }
+
+  void test_keywordInPlaceOfIdentifier() {
+// TODO(brianwilkerson) We could do better with this.
+    parseCompilationUnit("do() {}",
+        codes: [ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD]);
+  }
+
+  void test_logicalAndExpression_missing_LHS() {
+    BinaryExpression expression =
+        parseExpression("&& y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.leftOperand, isSimpleIdentifier);
+    expect(expression.leftOperand.isSynthetic, isTrue);
+  }
+
+  void test_logicalAndExpression_missing_LHS_RHS() {
+    BinaryExpression expression = parseExpression("&&", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isSimpleIdentifier);
+    expect(expression.leftOperand.isSynthetic, isTrue);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_logicalAndExpression_missing_RHS() {
+    BinaryExpression expression =
+        parseExpression("x &&", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_logicalAndExpression_precedence_bitwiseOr_left() {
+    BinaryExpression expression = parseExpression("| &&", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_logicalAndExpression_precedence_bitwiseOr_right() {
+    BinaryExpression expression = parseExpression("&& |", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.rightOperand, isBinaryExpression);
+  }
+
+  void test_logicalOrExpression_missing_LHS() {
+    BinaryExpression expression =
+        parseExpression("|| y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.leftOperand, isSimpleIdentifier);
+    expect(expression.leftOperand.isSynthetic, isTrue);
+  }
+
+  void test_logicalOrExpression_missing_LHS_RHS() {
+    BinaryExpression expression = parseExpression("||", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isSimpleIdentifier);
+    expect(expression.leftOperand.isSynthetic, isTrue);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_logicalOrExpression_missing_RHS() {
+    BinaryExpression expression =
+        parseExpression("x ||", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_logicalOrExpression_precedence_logicalAnd_left() {
+    BinaryExpression expression = parseExpression("&& ||", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_logicalOrExpression_precedence_logicalAnd_right() {
+    BinaryExpression expression = parseExpression("|| &&", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.rightOperand, isBinaryExpression);
+  }
+
+  void test_method_missingBody() {
+    parseCompilationUnit("class C { b() }",
+        errors: [expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 14, 1)]);
+  }
+
+  void test_missing_commaInArgumentList() {
+    MethodInvocation expression = parseExpression("f(x: 1 y: 2)",
+        errors: [expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 1)]);
+    NodeList<Expression> arguments = expression.argumentList.arguments;
+    expect(arguments, hasLength(2));
+  }
+
+  void test_missingComma_beforeNamedArgument() {
+    createParser('(a b: c)');
+    ArgumentList argumentList = parser.parseArgumentList();
+    expectNotNullIfNoErrors(argumentList);
+    listener
+        .assertErrors([expectedError(ParserErrorCode.EXPECTED_TOKEN, 3, 1)]);
+    expect(argumentList.arguments, hasLength(2));
+  }
+
+  void test_missingGet() {
+    CompilationUnit unit = parseCompilationUnit(r'''
+class C {
+  int length {}
+  void foo() {}
+}''', errors: [
+      expectedError(ParserErrorCode.MISSING_METHOD_PARAMETERS, 16, 6)
+    ]);
+    expect(unit, isNotNull);
+    ClassDeclaration classDeclaration =
+        unit.declarations[0] as ClassDeclaration;
+    NodeList<ClassMember> members = classDeclaration.members;
+    expect(members, hasLength(2));
+    expect(members[0], isMethodDeclaration);
+    ClassMember member = members[1];
+    expect(member, isMethodDeclaration);
+    expect((member as MethodDeclaration).name.name, "foo");
+  }
+
+  void test_missingIdentifier_afterAnnotation() {
+    createParser('@override }', expectedEndOffset: 10);
+    ClassMember member = parser.parseClassMember('C');
+    expectNotNullIfNoErrors(member);
+    listener.assertErrors(
+        [expectedError(ParserErrorCode.EXPECTED_CLASS_MEMBER, 10, 1)]);
+// TODO(danrubel): Consider generating a sub method so that the
+// existing annotation can be associated with a class member.
+    expect(member, isNull);
+  }
+
+  void test_missingSemicolon_varialeDeclarationList() {
+    void verify(CompilationUnitMember member, String expectedTypeName,
+        String expectedName, String expectedSemicolon) {
+      expect(member, isTopLevelVariableDeclaration);
+      TopLevelVariableDeclaration declaration = member;
+      VariableDeclarationList variableList = declaration.variables;
+      expect(variableList, isNotNull);
+      NodeList<VariableDeclaration> variables = variableList.variables;
+      expect(variables, hasLength(1));
+      VariableDeclaration variable = variables[0];
+      expect(variableList.type.toString(), expectedTypeName);
+      expect(variable.name.name, expectedName);
+      if (expectedSemicolon.isEmpty) {
+        expect(declaration.semicolon.isSynthetic, isTrue);
+      } else {
+        expect(declaration.semicolon.lexeme, expectedSemicolon);
+      }
+    }
+
+// Fasta considers the `n` an extraneous modifier
+// and parses this as a single top level declaration.
+// TODO(danrubel): A better recovery
+// would be to insert a synthetic comma after the `n`.
+    CompilationUnit unit = parseCompilationUnit('String n x = "";', codes: [
+      ParserErrorCode.EXPECTED_TOKEN,
+      ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE
+    ]);
+    expect(unit, isNotNull);
+    NodeList<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(2));
+    verify(declarations[0], 'String', 'n', '');
+    verify(declarations[1], 'null', 'x', ';');
+  }
+
+  void test_multiplicativeExpression_missing_LHS() {
+    BinaryExpression expression =
+        parseExpression("* y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.leftOperand, isSimpleIdentifier);
+    expect(expression.leftOperand.isSynthetic, isTrue);
+  }
+
+  void test_multiplicativeExpression_missing_LHS_RHS() {
+    BinaryExpression expression = parseExpression("*", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isSimpleIdentifier);
+    expect(expression.leftOperand.isSynthetic, isTrue);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_multiplicativeExpression_missing_RHS() {
+    BinaryExpression expression =
+        parseExpression("x *", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_multiplicativeExpression_missing_RHS_super() {
+    BinaryExpression expression =
+        parseExpression("super *", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_multiplicativeExpression_precedence_unary_left() {
+    BinaryExpression expression =
+        parseExpression("-x *", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.leftOperand, isPrefixExpression);
+  }
+
+  void test_multiplicativeExpression_precedence_unary_right() {
+    BinaryExpression expression =
+        parseExpression("* -y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.rightOperand, isPrefixExpression);
+  }
+
+  void test_multiplicativeExpression_super() {
+    BinaryExpression expression = parseExpression("super ==  ==", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND
+    ]);
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_namedParameterOutsideGroup() {
+    CompilationUnit unit =
+        parseCompilationUnit('class A { b(c: 0, Foo d: 0, e){} }', errors: [
+      expectedError(ParserErrorCode.NAMED_PARAMETER_OUTSIDE_GROUP, 13, 1),
+      expectedError(ParserErrorCode.NAMED_PARAMETER_OUTSIDE_GROUP, 23, 1)
+    ]);
+    expect(unit.declarations, hasLength(1));
+    ClassDeclaration classA = unit.declarations[0];
+    expect(classA.members, hasLength(1));
+    MethodDeclaration method = classA.members[0];
+    NodeList<FormalParameter> parameters = method.parameters.parameters;
+    expect(parameters, hasLength(3));
+    expect(parameters[0].isNamed, isTrue);
+    expect(parameters[1].isNamed, isTrue);
+    expect(parameters[2].isRequired, isTrue);
+  }
+
+  void test_nonStringLiteralUri_import() {
+    parseCompilationUnit("import dart:io; class C {}", errors: [
+      expectedError(ParserErrorCode.EXPECTED_STRING_LITERAL, 7, 4),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 4),
+      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 7, 4),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 7, 4),
+      expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 11, 1),
+      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 12, 2)
+    ]);
+  }
+
+  void test_prefixExpression_missing_operand_minus() {
+    PrefixExpression expression =
+        parseExpression("-", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.operand, isSimpleIdentifier);
+    expect(expression.operand.isSynthetic, isTrue);
+    expect(expression.operator.type, TokenType.MINUS);
+  }
+
+  void test_primaryExpression_argumentDefinitionTest() {
+    SimpleIdentifier expression = parsePrimaryExpression('?a',
+        expectedEndOffset: 0,
+        errors: [expectedError(ParserErrorCode.MISSING_IDENTIFIER, 0, 1)]);
+    expectNotNullIfNoErrors(expression);
+    expect(expression.isSynthetic, isTrue);
+  }
+
+  void test_propertyAccess_missing_LHS_RHS() {
+    Expression result = parseExpression(".", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    PrefixedIdentifier expression = result;
+    expect(expression.prefix.isSynthetic, isTrue);
+    expect(expression.period.lexeme, '.');
+    expect(expression.identifier.isSynthetic, isTrue);
+  }
+
+  void test_relationalExpression_missing_LHS() {
+    IsExpression expression =
+        parseExpression("is y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.expression, isSimpleIdentifier);
+    expect(expression.expression.isSynthetic, isTrue);
+  }
+
+  void test_relationalExpression_missing_LHS_RHS() {
+    parseExpression("is", codes: [
+      ParserErrorCode.EXPECTED_TYPE_NAME,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+  }
+
+  void test_relationalExpression_missing_RHS() {
+    IsExpression expression =
+        parseExpression("x is", codes: [ParserErrorCode.EXPECTED_TYPE_NAME]);
+    expect(expression.type, isTypeName);
+    expect(expression.type.isSynthetic, isTrue);
+  }
+
+  void test_relationalExpression_precedence_shift_right() {
+    parseExpression("<< is", codes: [
+      ParserErrorCode.EXPECTED_TYPE_NAME,
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+  }
+
+  void test_shiftExpression_missing_LHS() {
+    BinaryExpression expression =
+        parseExpression("<< y", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.leftOperand, isSimpleIdentifier);
+    expect(expression.leftOperand.isSynthetic, isTrue);
+  }
+
+  void test_shiftExpression_missing_LHS_RHS() {
+    BinaryExpression expression = parseExpression("<<", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isSimpleIdentifier);
+    expect(expression.leftOperand.isSynthetic, isTrue);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_shiftExpression_missing_RHS() {
+    BinaryExpression expression =
+        parseExpression("x <<", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_shiftExpression_missing_RHS_super() {
+    BinaryExpression expression = parseExpression("super <<",
+        codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+    expect(expression.rightOperand, isSimpleIdentifier);
+    expect(expression.rightOperand.isSynthetic, isTrue);
+  }
+
+  void test_shiftExpression_precedence_unary_left() {
+    BinaryExpression expression = parseExpression("+ <<", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_shiftExpression_precedence_unary_right() {
+    BinaryExpression expression = parseExpression("<< +", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.rightOperand, isBinaryExpression);
+  }
+
+  void test_shiftExpression_super() {
+    BinaryExpression expression = parseExpression("super << <<", codes: [
+      ParserErrorCode.MISSING_IDENTIFIER,
+      ParserErrorCode.MISSING_IDENTIFIER
+    ]);
+    expect(expression.leftOperand, isBinaryExpression);
+  }
+
+  void test_typedef_eof() {
+    CompilationUnit unit = parseCompilationUnit("typedef n", codes: [
+      ParserErrorCode.EXPECTED_TOKEN,
+      ParserErrorCode.MISSING_TYPEDEF_PARAMETERS
+    ]);
+    NodeList<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(1));
+    CompilationUnitMember member = declarations[0];
+    expect(member, isFunctionTypeAlias);
+  }
+
+  void test_unaryPlus() {
+    parseExpression("+2", codes: [ParserErrorCode.MISSING_IDENTIFIER]);
+  }
+}
diff --git a/pkg/analyzer/test/generated/simple_parser_test.dart b/pkg/analyzer/test/generated/simple_parser_test.dart
new file mode 100644
index 0000000..c3f40da
--- /dev/null
+++ b/pkg/analyzer/test/generated/simple_parser_test.dart
@@ -0,0 +1,2090 @@
+// Copyright (c) 2020, 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.
+
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/ast/token.dart';
+import 'package:analyzer/src/dart/scanner/scanner.dart';
+import 'package:analyzer/src/error/codes.dart';
+import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../util/ast_type_matchers.dart';
+import 'parser_test_base.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(SimpleParserTest);
+  });
+}
+
+/// Parser tests that test individual parsing methods. The code fragments should
+/// be as minimal as possible in order to test the method, but should not test
+/// the interactions between the method under test and other methods.
+///
+/// More complex tests should be defined in the class [ComplexParserTest].
+@reflectiveTest
+class SimpleParserTest extends FastaParserTestCase {
+  ConstructorName parseConstructorName(String name) {
+    createParser('new $name();');
+    Statement statement = parser.parseStatement2();
+    expect(statement, isExpressionStatement);
+    Expression expression = (statement as ExpressionStatement).expression;
+    expect(expression, isInstanceCreationExpression);
+    return (expression as InstanceCreationExpression).constructorName;
+  }
+
+  ExtendsClause parseExtendsClause(String clause) {
+    createParser('class TestClass $clause {}');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expect(unit, isNotNull);
+    expect(unit.declarations, hasLength(1));
+    ClassDeclaration classDecl = unit.declarations[0];
+    expect(classDecl, isNotNull);
+    return classDecl.extendsClause;
+  }
+
+  List<SimpleIdentifier> parseIdentifierList(String identifiers) {
+    createParser('show $identifiers');
+    List<Combinator> combinators = parser.parseCombinators();
+    expect(combinators, hasLength(1));
+    return (combinators[0] as ShowCombinator).shownNames;
+  }
+
+  ImplementsClause parseImplementsClause(String clause) {
+    createParser('class TestClass $clause {}');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expect(unit, isNotNull);
+    expect(unit.declarations, hasLength(1));
+    ClassDeclaration classDecl = unit.declarations[0];
+    expect(classDecl, isNotNull);
+    return classDecl.implementsClause;
+  }
+
+  LibraryIdentifier parseLibraryIdentifier(String name) {
+    createParser('library $name;');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expect(unit, isNotNull);
+    expect(unit.directives, hasLength(1));
+    LibraryDirective directive = unit.directives[0];
+    return directive.name;
+  }
+
+  /// Parse the given [content] as a sequence of statements by enclosing it in a
+  /// block. The [expectedCount] is the number of statements that are expected
+  /// to be parsed. If [errorCodes] are provided, verify that the error codes of
+  /// the errors that are expected are found.
+  void parseStatementList(String content, int expectedCount) {
+    Statement statement = parseStatement('{$content}');
+    expect(statement, isBlock);
+    Block block = statement;
+    expect(block.statements, hasLength(expectedCount));
+  }
+
+  VariableDeclaration parseVariableDeclaration(String declaration) {
+    createParser(declaration);
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expect(unit, isNotNull);
+    expect(unit.declarations, hasLength(1));
+    TopLevelVariableDeclaration decl = unit.declarations[0];
+    expect(decl, isNotNull);
+    return decl.variables.variables[0];
+  }
+
+  WithClause parseWithClause(String clause) {
+    createParser('class TestClass extends Object $clause {}');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expect(unit, isNotNull);
+    expect(unit.declarations, hasLength(1));
+    ClassDeclaration classDecl = unit.declarations[0];
+    expect(classDecl, isNotNull);
+    return classDecl.withClause;
+  }
+
+  void test_classDeclaration_complexTypeParam() {
+    CompilationUnit unit = parseCompilationUnit('''
+class C<@Foo.bar(const [], const [1], const{"":r""}, 0xFF + 2, .3, 4.5) T> {}
+''');
+    ClassDeclaration clazz = unit.declarations[0];
+    expect(clazz.name.name, 'C');
+    expect(clazz.typeParameters.typeParameters, hasLength(1));
+    TypeParameter typeParameter = clazz.typeParameters.typeParameters[0];
+    expect(typeParameter.name.name, 'T');
+    expect(typeParameter.metadata, hasLength(1));
+    Annotation metadata = typeParameter.metadata[0];
+    expect(metadata.name.name, 'Foo.bar');
+  }
+
+  void test_method_name_notNull_37733() {
+    // https://github.com/dart-lang/sdk/issues/37733
+    var unit = parseCompilationUnit(r'class C { f(<T>()); }', errors: [
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 12, 1),
+    ]);
+    var classDeclaration = unit.declarations[0] as ClassDeclaration;
+    var method = classDeclaration.members[0] as MethodDeclaration;
+    expect(method.parameters.parameters, hasLength(1));
+    var parameter =
+        method.parameters.parameters[0] as FunctionTypedFormalParameter;
+    expect(parameter.identifier, isNotNull);
+  }
+
+  void test_parseAnnotation_n1() {
+    createParser('@A');
+    Annotation annotation = parser.parseAnnotation();
+    expectNotNullIfNoErrors(annotation);
+    assertNoErrors();
+    expect(annotation.atSign, isNotNull);
+    expect(annotation.name, isNotNull);
+    expect(annotation.period, isNull);
+    expect(annotation.constructorName, isNull);
+    expect(annotation.arguments, isNull);
+  }
+
+  void test_parseAnnotation_n1_a() {
+    createParser('@A(x,y)');
+    Annotation annotation = parser.parseAnnotation();
+    expectNotNullIfNoErrors(annotation);
+    assertNoErrors();
+    expect(annotation.atSign, isNotNull);
+    expect(annotation.name, isNotNull);
+    expect(annotation.period, isNull);
+    expect(annotation.constructorName, isNull);
+    expect(annotation.arguments, isNotNull);
+  }
+
+  void test_parseAnnotation_n2() {
+    createParser('@A.B');
+    Annotation annotation = parser.parseAnnotation();
+    expectNotNullIfNoErrors(annotation);
+    assertNoErrors();
+    expect(annotation.atSign, isNotNull);
+    expect(annotation.name, isNotNull);
+    expect(annotation.period, isNull);
+    expect(annotation.constructorName, isNull);
+    expect(annotation.arguments, isNull);
+  }
+
+  void test_parseAnnotation_n2_a() {
+    createParser('@A.B(x,y)');
+    Annotation annotation = parser.parseAnnotation();
+    expectNotNullIfNoErrors(annotation);
+    assertNoErrors();
+    expect(annotation.atSign, isNotNull);
+    expect(annotation.name, isNotNull);
+    expect(annotation.period, isNull);
+    expect(annotation.constructorName, isNull);
+    expect(annotation.arguments, isNotNull);
+  }
+
+  void test_parseAnnotation_n3() {
+    createParser('@A.B.C');
+    Annotation annotation = parser.parseAnnotation();
+    expectNotNullIfNoErrors(annotation);
+    assertNoErrors();
+    expect(annotation.atSign, isNotNull);
+    expect(annotation.name, isNotNull);
+    expect(annotation.period, isNotNull);
+    expect(annotation.constructorName, isNotNull);
+    expect(annotation.arguments, isNull);
+  }
+
+  void test_parseAnnotation_n3_a() {
+    createParser('@A.B.C(x,y)');
+    Annotation annotation = parser.parseAnnotation();
+    expectNotNullIfNoErrors(annotation);
+    assertNoErrors();
+    expect(annotation.atSign, isNotNull);
+    expect(annotation.name, isNotNull);
+    expect(annotation.period, isNotNull);
+    expect(annotation.constructorName, isNotNull);
+    expect(annotation.arguments, isNotNull);
+  }
+
+  test_parseArgument() {
+    Expression result = parseArgument('3');
+    expect(result, const TypeMatcher<IntegerLiteral>());
+    IntegerLiteral literal = result;
+    expect(literal.value, 3);
+  }
+
+  test_parseArgument_named() {
+    Expression result = parseArgument('foo: "a"');
+    expect(result, const TypeMatcher<NamedExpression>());
+    NamedExpression expression = result;
+    StringLiteral literal = expression.expression;
+    expect(literal.stringValue, 'a');
+  }
+
+  void test_parseArgumentList_empty() {
+    createParser('()');
+    ArgumentList argumentList = parser.parseArgumentList();
+    expectNotNullIfNoErrors(argumentList);
+    assertNoErrors();
+    NodeList<Expression> arguments = argumentList.arguments;
+    expect(arguments, hasLength(0));
+  }
+
+  void test_parseArgumentList_mixed() {
+    createParser('(w, x, y: y, z: z)');
+    ArgumentList argumentList = parser.parseArgumentList();
+    expectNotNullIfNoErrors(argumentList);
+    assertNoErrors();
+    NodeList<Expression> arguments = argumentList.arguments;
+    expect(arguments, hasLength(4));
+  }
+
+  void test_parseArgumentList_noNamed() {
+    createParser('(x, y, z)');
+    ArgumentList argumentList = parser.parseArgumentList();
+    expectNotNullIfNoErrors(argumentList);
+    assertNoErrors();
+    NodeList<Expression> arguments = argumentList.arguments;
+    expect(arguments, hasLength(3));
+  }
+
+  void test_parseArgumentList_onlyNamed() {
+    createParser('(x: x, y: y)');
+    ArgumentList argumentList = parser.parseArgumentList();
+    expectNotNullIfNoErrors(argumentList);
+    assertNoErrors();
+    NodeList<Expression> arguments = argumentList.arguments;
+    expect(arguments, hasLength(2));
+  }
+
+  void test_parseArgumentList_trailing_comma() {
+    createParser('(x, y, z,)');
+    ArgumentList argumentList = parser.parseArgumentList();
+    expectNotNullIfNoErrors(argumentList);
+    assertNoErrors();
+    NodeList<Expression> arguments = argumentList.arguments;
+    expect(arguments, hasLength(3));
+  }
+
+  void test_parseArgumentList_typeArguments() {
+    createParser('(a<b,c>(d))');
+    ArgumentList argumentList = parser.parseArgumentList();
+    expectNotNullIfNoErrors(argumentList);
+    assertNoErrors();
+    NodeList<Expression> arguments = argumentList.arguments;
+    expect(arguments, hasLength(1));
+  }
+
+  void test_parseArgumentList_typeArguments_none() {
+    createParser('(a<b,p.q.c>(d))');
+    ArgumentList argumentList = parser.parseArgumentList();
+    expectNotNullIfNoErrors(argumentList);
+    assertNoErrors();
+    NodeList<Expression> arguments = argumentList.arguments;
+    expect(arguments, hasLength(2));
+  }
+
+  void test_parseArgumentList_typeArguments_prefixed() {
+    createParser('(a<b,p.c>(d))');
+    ArgumentList argumentList = parser.parseArgumentList();
+    expectNotNullIfNoErrors(argumentList);
+    assertNoErrors();
+    NodeList<Expression> arguments = argumentList.arguments;
+    expect(arguments, hasLength(1));
+  }
+
+  void test_parseCombinators_h() {
+    createParser('hide a');
+    List<Combinator> combinators = parser.parseCombinators();
+    expectNotNullIfNoErrors(combinators);
+    assertNoErrors();
+    expect(combinators, hasLength(1));
+    HideCombinator combinator = combinators[0] as HideCombinator;
+    expect(combinator, isNotNull);
+    expect(combinator.keyword, isNotNull);
+    expect(combinator.hiddenNames, hasLength(1));
+  }
+
+  void test_parseCombinators_hs() {
+    createParser('hide a show b');
+    List<Combinator> combinators = parser.parseCombinators();
+    expectNotNullIfNoErrors(combinators);
+    assertNoErrors();
+    expect(combinators, hasLength(2));
+    HideCombinator hideCombinator = combinators[0] as HideCombinator;
+    expect(hideCombinator, isNotNull);
+    expect(hideCombinator.keyword, isNotNull);
+    expect(hideCombinator.hiddenNames, hasLength(1));
+    ShowCombinator showCombinator = combinators[1] as ShowCombinator;
+    expect(showCombinator, isNotNull);
+    expect(showCombinator.keyword, isNotNull);
+    expect(showCombinator.shownNames, hasLength(1));
+  }
+
+  void test_parseCombinators_hshs() {
+    createParser('hide a show b hide c show d');
+    List<Combinator> combinators = parser.parseCombinators();
+    expectNotNullIfNoErrors(combinators);
+    assertNoErrors();
+    expect(combinators, hasLength(4));
+  }
+
+  void test_parseCombinators_s() {
+    createParser('show a');
+    List<Combinator> combinators = parser.parseCombinators();
+    expectNotNullIfNoErrors(combinators);
+    assertNoErrors();
+    expect(combinators, hasLength(1));
+    ShowCombinator combinator = combinators[0] as ShowCombinator;
+    expect(combinator, isNotNull);
+    expect(combinator.keyword, isNotNull);
+    expect(combinator.shownNames, hasLength(1));
+  }
+
+  void test_parseCommentAndMetadata_c() {
+    createParser('/** 1 */ class C {}');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    assertNoErrors();
+    ClassDeclaration declaration = unit.declarations[0];
+    expect(declaration.documentationComment, isNotNull);
+    expect(declaration.metadata, isEmpty);
+  }
+
+  void test_parseCommentAndMetadata_cmc() {
+    createParser('/** 1 */ @A /** 2 */ class C {}');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    assertNoErrors();
+    ClassDeclaration declaration = unit.declarations[0];
+    Comment comment = declaration.documentationComment;
+    expect(comment.isDocumentation, isTrue);
+    expect(comment.tokens, hasLength(1));
+    expect(comment.tokens[0].lexeme, '/** 2 */');
+    expect(declaration.metadata, hasLength(1));
+  }
+
+  void test_parseCommentAndMetadata_cmcm() {
+    createParser('/** 1 */ @A /** 2 */ @B class C {}');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    assertNoErrors();
+    ClassDeclaration declaration = unit.declarations[0];
+    expect(declaration.documentationComment, isNotNull);
+    expect(declaration.metadata, hasLength(2));
+  }
+
+  void test_parseCommentAndMetadata_cmm() {
+    createParser('/** 1 */ @A @B class C {}');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    assertNoErrors();
+    ClassDeclaration declaration = unit.declarations[0];
+    expect(declaration.documentationComment, isNotNull);
+    expect(declaration.metadata, hasLength(2));
+  }
+
+  void test_parseCommentAndMetadata_m() {
+    createParser('@A class C {}');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    assertNoErrors();
+    ClassDeclaration declaration = unit.declarations[0];
+    expect(declaration.documentationComment, isNull);
+    expect(declaration.metadata, hasLength(1));
+  }
+
+  void test_parseCommentAndMetadata_mcm() {
+    createParser('@A /** 1 */ @B class C {}');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    assertNoErrors();
+    ClassDeclaration declaration = unit.declarations[0];
+    expect(declaration.documentationComment, isNotNull);
+    expect(declaration.metadata, hasLength(2));
+  }
+
+  void test_parseCommentAndMetadata_mcmc() {
+    createParser('@A /** 1 */ @B /** 2 */ class C {}');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    assertNoErrors();
+    ClassDeclaration declaration = unit.declarations[0];
+    expect(declaration.documentationComment, isNotNull);
+    expect(declaration.documentationComment.tokens[0].lexeme, contains('2'));
+    expect(declaration.metadata, hasLength(2));
+  }
+
+  void test_parseCommentAndMetadata_mix1() {
+    createParser(r'''
+/**
+ * aaa
+ */
+/**
+ * bbb
+ */
+class A {}
+''');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    assertNoErrors();
+    ClassDeclaration declaration = unit.declarations[0];
+    expect(declaration.metadata, hasLength(0));
+    List<Token> tokens = declaration.documentationComment.tokens;
+    expect(tokens, hasLength(1));
+    expect(tokens[0].lexeme, contains('bbb'));
+  }
+
+  void test_parseCommentAndMetadata_mix2() {
+    createParser(r'''
+/**
+ * aaa
+ */
+/// bbb
+/// ccc
+class B {}
+''');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    assertNoErrors();
+    ClassDeclaration declaration = unit.declarations[0];
+    expect(declaration.metadata, hasLength(0));
+    List<Token> tokens = declaration.documentationComment.tokens;
+    expect(tokens, hasLength(2));
+    expect(tokens[0].lexeme, contains('bbb'));
+    expect(tokens[1].lexeme, contains('ccc'));
+  }
+
+  void test_parseCommentAndMetadata_mix3() {
+    createParser(r'''
+/// aaa
+/// bbb
+/**
+ * ccc
+ */
+class C {}
+''');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    assertNoErrors();
+    ClassDeclaration declaration = unit.declarations[0];
+    expect(declaration.metadata, hasLength(0));
+    List<Token> tokens = declaration.documentationComment.tokens;
+    expect(tokens, hasLength(1));
+    expect(tokens[0].lexeme, contains('ccc'));
+  }
+
+  test_parseCommentAndMetadata_mix4() {
+    createParser(r'''
+/// aaa
+/// bbb
+/**
+ * ccc
+ */
+/// ddd
+class D {}
+''');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    assertNoErrors();
+    ClassDeclaration declaration = unit.declarations[0];
+    expect(declaration.metadata, hasLength(0));
+    List<Token> tokens = declaration.documentationComment.tokens;
+    expect(tokens, hasLength(1));
+    expect(tokens[0].lexeme, contains('ddd'));
+  }
+
+  test_parseCommentAndMetadata_mix5() {
+    createParser(r'''
+/**
+ * aaa
+ */
+// bbb
+class E {}
+''');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    assertNoErrors();
+    ClassDeclaration declaration = unit.declarations[0];
+    expect(declaration.metadata, hasLength(0));
+    List<Token> tokens = declaration.documentationComment.tokens;
+    expect(tokens, hasLength(1));
+    expect(tokens[0].lexeme, contains('aaa'));
+  }
+
+  void test_parseCommentAndMetadata_mm() {
+    createParser('@A @B(x) class C {}');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    assertNoErrors();
+    ClassDeclaration declaration = unit.declarations[0];
+    expect(declaration.documentationComment, isNull);
+    expect(declaration.metadata, hasLength(2));
+  }
+
+  void test_parseCommentAndMetadata_none() {
+    createParser('class C {}');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    assertNoErrors();
+    ClassDeclaration declaration = unit.declarations[0];
+    expect(declaration.documentationComment, isNull);
+    expect(declaration.metadata, isEmpty);
+  }
+
+  void test_parseCommentAndMetadata_singleLine() {
+    createParser(r'''
+/// 1
+/// 2
+class C {}
+''');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expectNotNullIfNoErrors(unit);
+    assertNoErrors();
+    ClassDeclaration declaration = unit.declarations[0];
+    expect(declaration.documentationComment, isNotNull);
+    expect(declaration.metadata, isEmpty);
+  }
+
+  void test_parseCommentReference_new_prefixed() {
+    createParser('');
+    CommentReference reference = parseCommentReference('new a.b', 7);
+    expectNotNullIfNoErrors(reference);
+    assertNoErrors();
+    expect(reference.identifier, isPrefixedIdentifier);
+    PrefixedIdentifier prefixedIdentifier = reference.identifier;
+    SimpleIdentifier prefix = prefixedIdentifier.prefix;
+    expect(prefix.token, isNotNull);
+    expect(prefix.name, "a");
+    expect(prefix.offset, 11);
+    expect(prefixedIdentifier.period, isNotNull);
+    SimpleIdentifier identifier = prefixedIdentifier.identifier;
+    expect(identifier.token, isNotNull);
+    expect(identifier.name, "b");
+    expect(identifier.offset, 13);
+  }
+
+  void test_parseCommentReference_new_simple() {
+    createParser('');
+    CommentReference reference = parseCommentReference('new a', 5);
+    expectNotNullIfNoErrors(reference);
+    assertNoErrors();
+    expect(reference.identifier, isSimpleIdentifier);
+    SimpleIdentifier identifier = reference.identifier;
+    expect(identifier.token, isNotNull);
+    expect(identifier.name, "a");
+    expect(identifier.offset, 9);
+  }
+
+  void test_parseCommentReference_operator_withKeyword_notPrefixed() {
+    createParser('');
+    CommentReference reference = parseCommentReference('operator ==', 5);
+    expectNotNullIfNoErrors(reference);
+    assertNoErrors();
+    expect(reference.identifier, isSimpleIdentifier);
+    SimpleIdentifier identifier = reference.identifier;
+    expect(identifier.token, isNotNull);
+    expect(identifier.name, "==");
+    expect(identifier.offset, 14);
+  }
+
+  void test_parseCommentReference_operator_withKeyword_prefixed() {
+    createParser('');
+    CommentReference reference = parseCommentReference('Object.operator==', 7);
+    expectNotNullIfNoErrors(reference);
+    assertNoErrors();
+    expect(reference.identifier, isPrefixedIdentifier);
+    PrefixedIdentifier prefixedIdentifier = reference.identifier;
+    SimpleIdentifier prefix = prefixedIdentifier.prefix;
+    expect(prefix.token, isNotNull);
+    expect(prefix.name, "Object");
+    expect(prefix.offset, 7);
+    expect(prefixedIdentifier.period, isNotNull);
+    SimpleIdentifier identifier = prefixedIdentifier.identifier;
+    expect(identifier.token, isNotNull);
+    expect(identifier.name, "==");
+    expect(identifier.offset, 22);
+  }
+
+  void test_parseCommentReference_operator_withoutKeyword_notPrefixed() {
+    createParser('');
+    CommentReference reference = parseCommentReference('==', 5);
+    expectNotNullIfNoErrors(reference);
+    assertNoErrors();
+    expect(reference.identifier, isSimpleIdentifier);
+    SimpleIdentifier identifier = reference.identifier;
+    expect(identifier.token, isNotNull);
+    expect(identifier.name, "==");
+    expect(identifier.offset, 5);
+  }
+
+  void test_parseCommentReference_operator_withoutKeyword_prefixed() {
+    createParser('');
+    CommentReference reference = parseCommentReference('Object.==', 7);
+    expectNotNullIfNoErrors(reference);
+    assertNoErrors();
+    expect(reference.identifier, isPrefixedIdentifier);
+    PrefixedIdentifier prefixedIdentifier = reference.identifier;
+    SimpleIdentifier prefix = prefixedIdentifier.prefix;
+    expect(prefix.token, isNotNull);
+    expect(prefix.name, "Object");
+    expect(prefix.offset, 7);
+    expect(prefixedIdentifier.period, isNotNull);
+    SimpleIdentifier identifier = prefixedIdentifier.identifier;
+    expect(identifier.token, isNotNull);
+    expect(identifier.name, "==");
+    expect(identifier.offset, 14);
+  }
+
+  void test_parseCommentReference_prefixed() {
+    createParser('');
+    CommentReference reference = parseCommentReference('a.b', 7);
+    expectNotNullIfNoErrors(reference);
+    assertNoErrors();
+    expect(reference.identifier, isPrefixedIdentifier);
+    PrefixedIdentifier prefixedIdentifier = reference.identifier;
+    SimpleIdentifier prefix = prefixedIdentifier.prefix;
+    expect(prefix.token, isNotNull);
+    expect(prefix.name, "a");
+    expect(prefix.offset, 7);
+    expect(prefixedIdentifier.period, isNotNull);
+    SimpleIdentifier identifier = prefixedIdentifier.identifier;
+    expect(identifier.token, isNotNull);
+    expect(identifier.name, "b");
+    expect(identifier.offset, 9);
+  }
+
+  void test_parseCommentReference_simple() {
+    createParser('');
+    CommentReference reference = parseCommentReference('a', 5);
+    expectNotNullIfNoErrors(reference);
+    assertNoErrors();
+    expect(reference.identifier, isSimpleIdentifier);
+    SimpleIdentifier identifier = reference.identifier;
+    expect(identifier.token, isNotNull);
+    expect(identifier.name, "a");
+    expect(identifier.offset, 5);
+  }
+
+  void test_parseCommentReference_synthetic() {
+    createParser('');
+    CommentReference reference = parseCommentReference('', 5);
+    expectNotNullIfNoErrors(reference);
+    assertNoErrors();
+    expect(reference.identifier, isSimpleIdentifier);
+    SimpleIdentifier identifier = reference.identifier;
+    expect(identifier, isNotNull);
+    expect(identifier.isSynthetic, isTrue);
+    expect(identifier.token, isNotNull);
+    expect(identifier.name, "");
+    expect(identifier.offset, 5);
+    // Should end with EOF token.
+    Token nextToken = identifier.token.next;
+    expect(nextToken, isNotNull);
+    expect(nextToken.type, TokenType.EOF);
+  }
+
+  @failingTest
+  void test_parseCommentReference_this() {
+    // This fails because we are returning null from the method and asserting
+    // that the return value is not null.
+    createParser('');
+    CommentReference reference = parseCommentReference('this', 5);
+    expectNotNullIfNoErrors(reference);
+    assertNoErrors();
+    SimpleIdentifier identifier = reference.identifier;
+    expect(identifier.token, isNotNull);
+    expect(identifier.name, "a");
+    expect(identifier.offset, 5);
+  }
+
+  void test_parseCommentReferences_33738() {
+    CompilationUnit unit =
+        parseCompilationUnit('/** [String] */ abstract class Foo {}');
+    ClassDeclaration clazz = unit.declarations[0];
+    Comment comment = clazz.documentationComment;
+    expect(clazz.isAbstract, isTrue);
+    List<CommentReference> references = comment.references;
+    expect(references, hasLength(1));
+    CommentReference reference = references[0];
+    expect(reference, isNotNull);
+    expect(reference.identifier, isNotNull);
+    expect(reference.offset, 5);
+  }
+
+  void test_parseCommentReferences_beforeAnnotation() {
+    CompilationUnit unit = parseCompilationUnit('''
+/// See [int] and [String]
+/// and [Object].
+@Annotation
+abstract class Foo {}
+''');
+    ClassDeclaration clazz = unit.declarations[0];
+    Comment comment = clazz.documentationComment;
+    expect(clazz.isAbstract, isTrue);
+    List<CommentReference> references = comment.references;
+    expect(references, hasLength(3));
+
+    expectReference(int index, String expectedText, int expectedOffset) {
+      CommentReference reference = references[index];
+      expect(reference.identifier.name, expectedText);
+      expect(reference.offset, expectedOffset);
+    }
+
+    expectReference(0, 'int', 9);
+    expectReference(1, 'String', 19);
+    expectReference(2, 'Object', 36);
+  }
+
+  void test_parseCommentReferences_complex() {
+    CompilationUnit unit = parseCompilationUnit('''
+/// This dartdoc comment [should] be ignored
+@Annotation
+/// This dartdoc comment is [included].
+// a non dartdoc comment [inbetween]
+/// See [int] and [String] but `not [a]`
+/// ```
+/// This [code] block should be ignored
+/// ```
+/// and [Object].
+abstract class Foo {}
+''');
+    ClassDeclaration clazz = unit.declarations[0];
+    Comment comment = clazz.documentationComment;
+    expect(clazz.isAbstract, isTrue);
+    List<CommentReference> references = comment.references;
+    expect(references, hasLength(4));
+
+    expectReference(int index, String expectedText, int expectedOffset) {
+      CommentReference reference = references[index];
+      expect(reference.identifier.name, expectedText);
+      expect(reference.offset, expectedOffset);
+    }
+
+    expectReference(0, 'included', 86);
+    expectReference(1, 'int', 143);
+    expectReference(2, 'String', 153);
+    expectReference(3, 'Object', 240);
+  }
+
+  void test_parseCommentReferences_multiLine() {
+    DocumentationCommentToken token = DocumentationCommentToken(
+        TokenType.MULTI_LINE_COMMENT, "/** xxx [a] yyy [bb] zzz */", 3);
+    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[token];
+    createParser('');
+    List<CommentReference> references = parser.parseCommentReferences(tokens);
+    expectNotNullIfNoErrors(references);
+    assertNoErrors();
+    expect(references, hasLength(2));
+    {
+      CommentReference reference = references[0];
+      expect(reference, isNotNull);
+      expect(reference.identifier, isNotNull);
+      expect(reference.offset, 12);
+      Token referenceToken = reference.identifier.beginToken;
+      expect(referenceToken.offset, 12);
+      expect(referenceToken.lexeme, 'a');
+    }
+    {
+      CommentReference reference = references[1];
+      expect(reference, isNotNull);
+      expect(reference.identifier, isNotNull);
+      expect(reference.offset, 20);
+      Token referenceToken = reference.identifier.beginToken;
+      expect(referenceToken.offset, 20);
+      expect(referenceToken.lexeme, 'bb');
+    }
+  }
+
+  void test_parseCommentReferences_notClosed_noIdentifier() {
+    DocumentationCommentToken docToken = DocumentationCommentToken(
+        TokenType.MULTI_LINE_COMMENT, "/** [ some text", 5);
+    createParser('');
+    List<CommentReference> references =
+        parser.parseCommentReferences(<DocumentationCommentToken>[docToken]);
+    expectNotNullIfNoErrors(references);
+    assertNoErrors();
+    expect(references, hasLength(1));
+    CommentReference reference = references[0];
+    Token referenceToken = reference.identifier.beginToken;
+    expect(reference, isNotNull);
+    expect(reference.identifier, isNotNull);
+    expect(reference.identifier.isSynthetic, isTrue);
+    expect(reference.identifier.name, "");
+    // Should end with EOF token.
+    Token nextToken = referenceToken.next;
+    expect(nextToken, isNotNull);
+    expect(nextToken.type, TokenType.EOF);
+  }
+
+  void test_parseCommentReferences_notClosed_withIdentifier() {
+    DocumentationCommentToken docToken = DocumentationCommentToken(
+        TokenType.MULTI_LINE_COMMENT, "/** [namePrefix some text", 5);
+    createParser('');
+    List<CommentReference> references =
+        parser.parseCommentReferences(<DocumentationCommentToken>[docToken]);
+    expectNotNullIfNoErrors(references);
+    assertNoErrors();
+    expect(references, hasLength(1));
+    CommentReference reference = references[0];
+    Token referenceToken = reference.identifier.beginToken;
+    expect(reference, isNotNull);
+    expect(referenceToken, same(reference.beginToken));
+    expect(reference.identifier, isNotNull);
+    expect(reference.identifier.isSynthetic, isFalse);
+    expect(reference.identifier.name, "namePrefix");
+    // Should end with EOF token.
+    Token nextToken = referenceToken.next;
+    expect(nextToken, isNotNull);
+    expect(nextToken.type, TokenType.EOF);
+  }
+
+  void test_parseCommentReferences_singleLine() {
+    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
+      DocumentationCommentToken(
+          TokenType.SINGLE_LINE_COMMENT, "/// xxx [a] yyy [b] zzz", 3),
+      DocumentationCommentToken(TokenType.SINGLE_LINE_COMMENT, "/// x [c]", 28)
+    ];
+    createParser('');
+    List<CommentReference> references = parser.parseCommentReferences(tokens);
+    expectNotNullIfNoErrors(references);
+    assertNoErrors();
+    expect(references, hasLength(3));
+    CommentReference reference = references[0];
+    expect(reference, isNotNull);
+    expect(reference.identifier, isNotNull);
+    expect(reference.offset, 12);
+    reference = references[1];
+    expect(reference, isNotNull);
+    expect(reference.identifier, isNotNull);
+    expect(reference.offset, 20);
+    reference = references[2];
+    expect(reference, isNotNull);
+    expect(reference.identifier, isNotNull);
+    expect(reference.offset, 35);
+  }
+
+  void test_parseCommentReferences_skipCodeBlock_4spaces_block() {
+    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
+      DocumentationCommentToken(TokenType.MULTI_LINE_COMMENT,
+          "/**\n *     a[i]\n * non-code line\n */", 3)
+    ];
+    createParser('');
+    List<CommentReference> references = parser.parseCommentReferences(tokens);
+    expectNotNullIfNoErrors(references);
+    assertNoErrors();
+    expect(references, isEmpty);
+  }
+
+  void test_parseCommentReferences_skipCodeBlock_4spaces_lines() {
+    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
+      DocumentationCommentToken(
+          TokenType.SINGLE_LINE_COMMENT, "/// Code block:", 0),
+      DocumentationCommentToken(
+          TokenType.SINGLE_LINE_COMMENT, "///     a[i] == b[i]", 0)
+    ];
+    createParser('');
+    List<CommentReference> references = parser.parseCommentReferences(tokens);
+    expectNotNullIfNoErrors(references);
+    assertNoErrors();
+    expect(references, isEmpty);
+  }
+
+  void test_parseCommentReferences_skipCodeBlock_bracketed() {
+    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
+      DocumentationCommentToken(
+          TokenType.MULTI_LINE_COMMENT, "/** [:xxx [a] yyy:] [b] zzz */", 3)
+    ];
+    createParser('');
+    List<CommentReference> references = parser.parseCommentReferences(tokens);
+    expectNotNullIfNoErrors(references);
+    assertNoErrors();
+    expect(references, hasLength(1));
+    CommentReference reference = references[0];
+    expect(reference, isNotNull);
+    expect(reference.identifier, isNotNull);
+    expect(reference.offset, 24);
+  }
+
+  void test_parseCommentReferences_skipCodeBlock_gitHub() {
+    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
+      DocumentationCommentToken(
+          TokenType.MULTI_LINE_COMMENT, "/** `a[i]` and [b] */", 0)
+    ];
+    createParser('');
+    List<CommentReference> references = parser.parseCommentReferences(tokens);
+    expectNotNullIfNoErrors(references);
+    assertNoErrors();
+    expect(references, hasLength(1));
+    CommentReference reference = references[0];
+    expect(reference, isNotNull);
+    expect(reference.identifier, isNotNull);
+    expect(reference.offset, 16);
+  }
+
+  void test_parseCommentReferences_skipCodeBlock_gitHub_multiLine() {
+    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
+      DocumentationCommentToken(
+          TokenType.MULTI_LINE_COMMENT,
+          r'''
+/**
+ * First.
+ * ```dart
+ * Some [int] reference.
+ * ```
+ * Last.
+ */
+''',
+          3)
+    ];
+    createParser('');
+    List<CommentReference> references = parser.parseCommentReferences(tokens);
+    expectNotNullIfNoErrors(references);
+    assertNoErrors();
+    expect(references, isEmpty);
+  }
+
+  void test_parseCommentReferences_skipCodeBlock_gitHub_multiLine_lines() {
+    String commentText = r'''
+/// First.
+/// ```dart
+/// Some [int] reference.
+/// ```
+/// Last.
+''';
+    List<DocumentationCommentToken> tokens = commentText
+        .split('\n')
+        .map((line) =>
+            DocumentationCommentToken(TokenType.SINGLE_LINE_COMMENT, line, 0))
+        .toList();
+    createParser('');
+    List<CommentReference> references = parser.parseCommentReferences(tokens);
+    expectNotNullIfNoErrors(references);
+    assertNoErrors();
+    expect(references, isEmpty);
+  }
+
+  void test_parseCommentReferences_skipCodeBlock_gitHub_notTerminated() {
+    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
+      DocumentationCommentToken(
+          TokenType.MULTI_LINE_COMMENT, "/** `a[i] and [b] */", 0)
+    ];
+    createParser('');
+    List<CommentReference> references = parser.parseCommentReferences(tokens);
+    expectNotNullIfNoErrors(references);
+    assertNoErrors();
+    expect(references, hasLength(2));
+  }
+
+  void test_parseCommentReferences_skipCodeBlock_spaces() {
+    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
+      DocumentationCommentToken(TokenType.MULTI_LINE_COMMENT,
+          "/**\n *     a[i]\n * xxx [i] zzz\n */", 3)
+    ];
+    createParser('');
+    List<CommentReference> references = parser.parseCommentReferences(tokens);
+    expectNotNullIfNoErrors(references);
+    assertNoErrors();
+    expect(references, hasLength(1));
+    CommentReference reference = references[0];
+    expect(reference, isNotNull);
+    expect(reference.identifier, isNotNull);
+    expect(reference.offset, 27);
+  }
+
+  @failingTest
+  void test_parseCommentReferences_skipLink_direct_multiLine() {
+    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
+      DocumentationCommentToken(
+          TokenType.MULTI_LINE_COMMENT,
+          '''
+/**
+ * [a link split across multiple
+ * lines](http://www.google.com) [b] zzz
+ */
+''',
+          3)
+    ];
+    createParser('');
+    List<CommentReference> references = parser.parseCommentReferences(tokens);
+    expectNotNullIfNoErrors(references);
+    assertNoErrors();
+    expect(references, hasLength(1));
+    CommentReference reference = references[0];
+    expect(reference, isNotNull);
+    expect(reference.identifier, isNotNull);
+    expect(reference.offset, 74);
+  }
+
+  void test_parseCommentReferences_skipLink_direct_singleLine() {
+    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
+      DocumentationCommentToken(TokenType.MULTI_LINE_COMMENT,
+          "/** [a](http://www.google.com) [b] zzz */", 3)
+    ];
+    createParser('');
+    List<CommentReference> references = parser.parseCommentReferences(tokens);
+    expectNotNullIfNoErrors(references);
+    assertNoErrors();
+    expect(references, hasLength(1));
+    CommentReference reference = references[0];
+    expect(reference, isNotNull);
+    expect(reference.identifier, isNotNull);
+    expect(reference.offset, 35);
+  }
+
+  @failingTest
+  void test_parseCommentReferences_skipLink_reference_multiLine() {
+    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
+      DocumentationCommentToken(
+          TokenType.MULTI_LINE_COMMENT,
+          '''
+/**
+ * [a link split across multiple
+ * lines][c] [b] zzz
+ */
+''',
+          3)
+    ];
+    createParser('');
+    List<CommentReference> references = parser.parseCommentReferences(tokens);
+    expectNotNullIfNoErrors(references);
+    assertNoErrors();
+    expect(references, hasLength(1));
+    CommentReference reference = references[0];
+    expect(reference, isNotNull);
+    expect(reference.identifier, isNotNull);
+    expect(reference.offset, 54);
+  }
+
+  void test_parseCommentReferences_skipLink_reference_singleLine() {
+    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
+      DocumentationCommentToken(
+          TokenType.MULTI_LINE_COMMENT, "/** [a][c] [b] zzz */", 3)
+    ];
+    createParser('');
+    List<CommentReference> references = parser.parseCommentReferences(tokens);
+    expectNotNullIfNoErrors(references);
+    assertNoErrors();
+    expect(references, hasLength(1));
+    CommentReference reference = references[0];
+    expect(reference, isNotNull);
+    expect(reference.identifier, isNotNull);
+    expect(reference.offset, 15);
+  }
+
+  void test_parseCommentReferences_skipLinkDefinition() {
+    List<DocumentationCommentToken> tokens = <DocumentationCommentToken>[
+      DocumentationCommentToken(TokenType.MULTI_LINE_COMMENT,
+          "/** [a]: http://www.google.com (Google) [b] zzz */", 3)
+    ];
+    createParser('');
+    List<CommentReference> references = parser.parseCommentReferences(tokens);
+    expectNotNullIfNoErrors(references);
+    assertNoErrors();
+    expect(references, hasLength(1));
+    CommentReference reference = references[0];
+    expect(reference, isNotNull);
+    expect(reference.identifier, isNotNull);
+    expect(reference.offset, 44);
+  }
+
+  void test_parseConfiguration_noOperator_dottedIdentifier() {
+    createParser("if (a.b) 'c.dart'");
+    Configuration configuration = parser.parseConfiguration();
+    expectNotNullIfNoErrors(configuration);
+    assertNoErrors();
+    expect(configuration.ifKeyword, isNotNull);
+    expect(configuration.leftParenthesis, isNotNull);
+    expectDottedName(configuration.name, ["a", "b"]);
+    expect(configuration.equalToken, isNull);
+    expect(configuration.value, isNull);
+    expect(configuration.rightParenthesis, isNotNull);
+    expect(configuration.uri, isNotNull);
+  }
+
+  void test_parseConfiguration_noOperator_simpleIdentifier() {
+    createParser("if (a) 'b.dart'");
+    Configuration configuration = parser.parseConfiguration();
+    expectNotNullIfNoErrors(configuration);
+    assertNoErrors();
+    expect(configuration.ifKeyword, isNotNull);
+    expect(configuration.leftParenthesis, isNotNull);
+    expectDottedName(configuration.name, ["a"]);
+    expect(configuration.equalToken, isNull);
+    expect(configuration.value, isNull);
+    expect(configuration.rightParenthesis, isNotNull);
+    expect(configuration.uri, isNotNull);
+  }
+
+  void test_parseConfiguration_operator_dottedIdentifier() {
+    createParser("if (a.b == 'c') 'd.dart'");
+    Configuration configuration = parser.parseConfiguration();
+    expectNotNullIfNoErrors(configuration);
+    assertNoErrors();
+    expect(configuration.ifKeyword, isNotNull);
+    expect(configuration.leftParenthesis, isNotNull);
+    expectDottedName(configuration.name, ["a", "b"]);
+    expect(configuration.equalToken, isNotNull);
+    expect(configuration.value, isNotNull);
+    expect(configuration.rightParenthesis, isNotNull);
+    expect(configuration.uri, isNotNull);
+  }
+
+  void test_parseConfiguration_operator_simpleIdentifier() {
+    createParser("if (a == 'b') 'c.dart'");
+    Configuration configuration = parser.parseConfiguration();
+    expectNotNullIfNoErrors(configuration);
+    assertNoErrors();
+    expect(configuration.ifKeyword, isNotNull);
+    expect(configuration.leftParenthesis, isNotNull);
+    expectDottedName(configuration.name, ["a"]);
+    expect(configuration.equalToken, isNotNull);
+    expect(configuration.value, isNotNull);
+    expect(configuration.rightParenthesis, isNotNull);
+    expect(configuration.uri, isNotNull);
+  }
+
+  void test_parseConstructorName_named_noPrefix() {
+    ConstructorName name = parseConstructorName('A.n');
+    expectNotNullIfNoErrors(name);
+    assertNoErrors();
+    expect(name.type, isNotNull);
+    expect(name.period, isNull);
+    expect(name.name, isNull);
+  }
+
+  void test_parseConstructorName_named_prefixed() {
+    ConstructorName name = parseConstructorName('p.A.n');
+    expectNotNullIfNoErrors(name);
+    assertNoErrors();
+    expect(name.type, isNotNull);
+    expect(name.period, isNotNull);
+    expect(name.name, isNotNull);
+  }
+
+  void test_parseConstructorName_unnamed_noPrefix() {
+    ConstructorName name = parseConstructorName('A');
+    expectNotNullIfNoErrors(name);
+    assertNoErrors();
+    expect(name.type, isNotNull);
+    expect(name.period, isNull);
+    expect(name.name, isNull);
+  }
+
+  void test_parseConstructorName_unnamed_prefixed() {
+    ConstructorName name = parseConstructorName('p.A');
+    expectNotNullIfNoErrors(name);
+    assertNoErrors();
+    expect(name.type, isNotNull);
+    expect(name.period, isNull);
+    expect(name.name, isNull);
+  }
+
+  void test_parseDocumentationComment_block() {
+    createParser('/** */ class C {}');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    Comment comment = unit.declarations[0].documentationComment;
+    expectNotNullIfNoErrors(comment);
+    assertNoErrors();
+    expect(comment.isBlock, isFalse);
+    expect(comment.isDocumentation, isTrue);
+    expect(comment.isEndOfLine, isFalse);
+  }
+
+  void test_parseDocumentationComment_block_withReference() {
+    createParser('/** [a] */ class C {}');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    Comment comment = unit.declarations[0].documentationComment;
+    expectNotNullIfNoErrors(comment);
+    assertNoErrors();
+    expect(comment.isBlock, isFalse);
+    expect(comment.isDocumentation, isTrue);
+    expect(comment.isEndOfLine, isFalse);
+    NodeList<CommentReference> references = comment.references;
+    expect(references, hasLength(1));
+    CommentReference reference = references[0];
+    expect(reference, isNotNull);
+    expect(reference.offset, 5);
+  }
+
+  void test_parseDocumentationComment_endOfLine() {
+    createParser('/// \n/// \n class C {}');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    Comment comment = unit.declarations[0].documentationComment;
+    expectNotNullIfNoErrors(comment);
+    assertNoErrors();
+    expect(comment.isBlock, isFalse);
+    expect(comment.isDocumentation, isTrue);
+    expect(comment.isEndOfLine, isFalse);
+  }
+
+  void test_parseExtendsClause() {
+    ExtendsClause clause = parseExtendsClause('extends B');
+    expectNotNullIfNoErrors(clause);
+    assertNoErrors();
+    expect(clause.extendsKeyword, isNotNull);
+    expect(clause.superclass, isNotNull);
+    expect(clause.superclass, isTypeName);
+  }
+
+  void test_parseFunctionBody_block() {
+    createParser('{}');
+    FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
+    expectNotNullIfNoErrors(functionBody);
+    assertNoErrors();
+    expect(functionBody, isBlockFunctionBody);
+    BlockFunctionBody body = functionBody;
+    expect(body.keyword, isNull);
+    expect(body.star, isNull);
+    expect(body.block, isNotNull);
+    expect(body.isAsynchronous, isFalse);
+    expect(body.isGenerator, isFalse);
+    expect(body.isSynchronous, isTrue);
+  }
+
+  void test_parseFunctionBody_block_async() {
+    createParser('async {}');
+    FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
+    expectNotNullIfNoErrors(functionBody);
+    assertNoErrors();
+    expect(functionBody, isBlockFunctionBody);
+    BlockFunctionBody body = functionBody;
+    expect(body.keyword, isNotNull);
+    expect(body.keyword.lexeme, Keyword.ASYNC.lexeme);
+    expect(body.star, isNull);
+    expect(body.block, isNotNull);
+    expect(body.isAsynchronous, isTrue);
+    expect(body.isGenerator, isFalse);
+    expect(body.isSynchronous, isFalse);
+  }
+
+  void test_parseFunctionBody_block_asyncGenerator() {
+    createParser('async* {}');
+    FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
+    expectNotNullIfNoErrors(functionBody);
+    assertNoErrors();
+    expect(functionBody, isBlockFunctionBody);
+    BlockFunctionBody body = functionBody;
+    expect(body.keyword, isNotNull);
+    expect(body.keyword.lexeme, Keyword.ASYNC.lexeme);
+    expect(body.star, isNotNull);
+    expect(body.block, isNotNull);
+    expect(body.isAsynchronous, isTrue);
+    expect(body.isGenerator, isTrue);
+    expect(body.isSynchronous, isFalse);
+  }
+
+  void test_parseFunctionBody_block_syncGenerator() {
+    createParser('sync* {}');
+    FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
+    expectNotNullIfNoErrors(functionBody);
+    assertNoErrors();
+    expect(functionBody, isBlockFunctionBody);
+    BlockFunctionBody body = functionBody;
+    expect(body.keyword, isNotNull);
+    expect(body.keyword.lexeme, Keyword.SYNC.lexeme);
+    expect(body.star, isNotNull);
+    expect(body.block, isNotNull);
+    expect(body.isAsynchronous, isFalse);
+    expect(body.isGenerator, isTrue);
+    expect(body.isSynchronous, isTrue);
+  }
+
+  void test_parseFunctionBody_empty() {
+    createParser(';');
+    FunctionBody functionBody = parser.parseFunctionBody(true, null, false);
+    expectNotNullIfNoErrors(functionBody);
+    assertNoErrors();
+    expect(functionBody, isEmptyFunctionBody);
+    EmptyFunctionBody body = functionBody;
+    expect(body.semicolon, isNotNull);
+  }
+
+  void test_parseFunctionBody_expression() {
+    createParser('=> y;');
+    FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
+    expectNotNullIfNoErrors(functionBody);
+    assertNoErrors();
+    expect(functionBody, isExpressionFunctionBody);
+    ExpressionFunctionBody body = functionBody;
+    expect(body.keyword, isNull);
+    expect(body.functionDefinition, isNotNull);
+    expect(body.expression, isNotNull);
+    expect(body.semicolon, isNotNull);
+    expect(body.isAsynchronous, isFalse);
+    expect(body.isGenerator, isFalse);
+    expect(body.isSynchronous, isTrue);
+  }
+
+  void test_parseFunctionBody_expression_async() {
+    createParser('async => y;');
+    FunctionBody functionBody = parser.parseFunctionBody(false, null, false);
+    expectNotNullIfNoErrors(functionBody);
+    assertNoErrors();
+    expect(functionBody, isExpressionFunctionBody);
+    ExpressionFunctionBody body = functionBody;
+    expect(body.keyword, isNotNull);
+    expect(body.keyword.lexeme, Keyword.ASYNC.lexeme);
+    expect(body.functionDefinition, isNotNull);
+    expect(body.expression, isNotNull);
+    expect(body.semicolon, isNotNull);
+    expect(body.isAsynchronous, isTrue);
+    expect(body.isGenerator, isFalse);
+    expect(body.isSynchronous, isFalse);
+  }
+
+  void test_parseIdentifierList_multiple() {
+    List<SimpleIdentifier> list = parseIdentifierList('a, b, c');
+    expectNotNullIfNoErrors(list);
+    assertNoErrors();
+    expect(list, hasLength(3));
+  }
+
+  void test_parseIdentifierList_single() {
+    List<SimpleIdentifier> list = parseIdentifierList('a');
+    expectNotNullIfNoErrors(list);
+    assertNoErrors();
+    expect(list, hasLength(1));
+  }
+
+  void test_parseImplementsClause_multiple() {
+    ImplementsClause clause = parseImplementsClause('implements A, B, C');
+    expectNotNullIfNoErrors(clause);
+    assertNoErrors();
+    expect(clause.interfaces, hasLength(3));
+    expect(clause.implementsKeyword, isNotNull);
+  }
+
+  void test_parseImplementsClause_single() {
+    ImplementsClause clause = parseImplementsClause('implements A');
+    expectNotNullIfNoErrors(clause);
+    assertNoErrors();
+    expect(clause.interfaces, hasLength(1));
+    expect(clause.implementsKeyword, isNotNull);
+  }
+
+  void test_parseInstanceCreation_keyword_33647() {
+    enableOptionalNewAndConst = true;
+    CompilationUnit unit = parseCompilationUnit('''
+var c = new Future<int>.sync(() => 3).then<int>((e) => e);
+''');
+    expect(unit, isNotNull);
+    TopLevelVariableDeclaration v = unit.declarations[0];
+    MethodInvocation init = v.variables.variables[0].initializer;
+    expect(init.methodName.name, 'then');
+    NodeList<TypeAnnotation> typeArg = init.typeArguments.arguments;
+    expect(typeArg, hasLength(1));
+    expect(typeArg[0].beginToken.lexeme, 'int');
+  }
+
+  void test_parseInstanceCreation_noKeyword_33647() {
+    enableOptionalNewAndConst = true;
+    CompilationUnit unit = parseCompilationUnit('''
+var c = Future<int>.sync(() => 3).then<int>((e) => e);
+''');
+    expect(unit, isNotNull);
+    TopLevelVariableDeclaration v = unit.declarations[0];
+    MethodInvocation init = v.variables.variables[0].initializer;
+    expect(init.methodName.name, 'then');
+    NodeList<TypeAnnotation> typeArg = init.typeArguments.arguments;
+    expect(typeArg, hasLength(1));
+    expect(typeArg[0].beginToken.lexeme, 'int');
+  }
+
+  void test_parseInstanceCreation_noKeyword_noPrefix() {
+    enableOptionalNewAndConst = true;
+    createParser('f() => C<E>.n();');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expect(unit, isNotNull);
+    FunctionDeclaration f = unit.declarations[0];
+    ExpressionFunctionBody body = f.functionExpression.body;
+    expect(body.expression, isInstanceCreationExpression);
+    InstanceCreationExpressionImpl creation = body.expression;
+    expect(creation.keyword, isNull);
+    ConstructorName constructorName = creation.constructorName;
+    expect(constructorName.type.toSource(), 'C<E>');
+    expect(constructorName.period, isNotNull);
+    expect(constructorName.name, isNotNull);
+    expect(creation.argumentList, isNotNull);
+    expect(creation.typeArguments, isNull);
+  }
+
+  void test_parseInstanceCreation_noKeyword_noPrefix_34403() {
+    enableOptionalNewAndConst = true;
+    createParser('f() => C<E>.n<B>();');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expect(unit, isNotNull);
+    FunctionDeclaration f = unit.declarations[0];
+    ExpressionFunctionBody body = f.functionExpression.body;
+    expect(body.expression, isInstanceCreationExpression);
+    InstanceCreationExpressionImpl creation = body.expression;
+    expect(creation.keyword, isNull);
+    ConstructorName constructorName = creation.constructorName;
+    expect(constructorName.type.toSource(), 'C<E>');
+    expect(constructorName.period, isNotNull);
+    expect(constructorName.name, isNotNull);
+    expect(creation.argumentList, isNotNull);
+    expect(creation.typeArguments.arguments, hasLength(1));
+  }
+
+  void test_parseInstanceCreation_noKeyword_prefix() {
+    enableOptionalNewAndConst = true;
+    createParser('f() => p.C<E>.n();');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expect(unit, isNotNull);
+    FunctionDeclaration f = unit.declarations[0];
+    ExpressionFunctionBody body = f.functionExpression.body;
+    expect(body.expression, isInstanceCreationExpression);
+    InstanceCreationExpression creation = body.expression;
+    expect(creation.keyword, isNull);
+    ConstructorName constructorName = creation.constructorName;
+    expect(constructorName.type.toSource(), 'p.C<E>');
+    expect(constructorName.period, isNotNull);
+    expect(constructorName.name, isNotNull);
+    expect(creation.argumentList, isNotNull);
+  }
+
+  void test_parseInstanceCreation_noKeyword_varInit() {
+    enableOptionalNewAndConst = true;
+    createParser('''
+class C<T, S> {}
+void main() {final c = C<int, int Function(String)>();}
+''');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expect(unit, isNotNull);
+    FunctionDeclaration f = unit.declarations[1];
+    BlockFunctionBody body = f.functionExpression.body;
+    VariableDeclarationStatement statement = body.block.statements[0];
+    VariableDeclaration variable = statement.variables.variables[0];
+    MethodInvocation creation = variable.initializer;
+    expect(creation.methodName.name, 'C');
+    expect(creation.typeArguments.toSource(), '<int, int Function(String)>');
+  }
+
+  void test_parseLibraryIdentifier_builtin() {
+    String name = "deferred";
+    LibraryIdentifier identifier = parseLibraryIdentifier(name);
+    expectNotNullIfNoErrors(identifier);
+    assertNoErrors();
+    expect(identifier.name, name);
+    expect(identifier.beginToken.type.isBuiltIn, isTrue);
+  }
+
+  void test_parseLibraryIdentifier_invalid() {
+    parseCompilationUnit('library <myLibId>;', errors: [
+      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 0, 7),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 17, 1),
+    ]);
+  }
+
+  void test_parseLibraryIdentifier_multiple() {
+    String name = "a.b.c";
+    LibraryIdentifier identifier = parseLibraryIdentifier(name);
+    expectNotNullIfNoErrors(identifier);
+    assertNoErrors();
+    expect(identifier.name, name);
+  }
+
+  void test_parseLibraryIdentifier_pseudo() {
+    String name = "await";
+    LibraryIdentifier identifier = parseLibraryIdentifier(name);
+    expectNotNullIfNoErrors(identifier);
+    assertNoErrors();
+    expect(identifier.name, name);
+    expect(identifier.beginToken.type.isPseudo, isTrue);
+  }
+
+  void test_parseLibraryIdentifier_single() {
+    String name = "a";
+    LibraryIdentifier identifier = parseLibraryIdentifier(name);
+    expectNotNullIfNoErrors(identifier);
+    assertNoErrors();
+    expect(identifier.name, name);
+  }
+
+  void test_parseOptionalReturnType() {
+    // TODO(brianwilkerson) Implement tests for this method.
+  }
+
+  void test_parseReturnStatement_noValue() {
+    ReturnStatement statement = parseStatement('return;');
+    expectNotNullIfNoErrors(statement);
+    assertNoErrors();
+    expect(statement.returnKeyword, isNotNull);
+    expect(statement.expression, isNull);
+    expect(statement.semicolon, isNotNull);
+  }
+
+  void test_parseReturnStatement_value() {
+    ReturnStatement statement = parseStatement('return x;');
+    expectNotNullIfNoErrors(statement);
+    assertNoErrors();
+    expect(statement.returnKeyword, isNotNull);
+    expect(statement.expression, isNotNull);
+    expect(statement.semicolon, isNotNull);
+  }
+
+  void test_parseStatement_function_noReturnType() {
+    createParser('''
+Function<A>(core.List<core.int> x) m() => null;
+''');
+    Statement statement = parser.parseStatement2();
+    expect(statement, isFunctionDeclarationStatement);
+    expect(
+        (statement as FunctionDeclarationStatement)
+            .functionDeclaration
+            .functionExpression
+            .body,
+        isExpressionFunctionBody);
+  }
+
+  void test_parseStatements_multiple() {
+    parseStatementList("return; return;", 2);
+  }
+
+  void test_parseStatements_single() {
+    parseStatementList("return;", 1);
+  }
+
+  void test_parseTypeAnnotation_function_noReturnType_noParameters() {
+    createParser('Function()');
+    GenericFunctionType functionType = parser.parseTypeAnnotation(false);
+    expectNotNullIfNoErrors(functionType);
+    assertNoErrors();
+    expect(functionType.returnType, isNull);
+    expect(functionType.functionKeyword, isNotNull);
+    expect(functionType.typeParameters, isNull);
+    FormalParameterList parameterList = functionType.parameters;
+    expect(parameterList, isNotNull);
+    expect(parameterList.parameters, hasLength(0));
+  }
+
+  void test_parseTypeAnnotation_function_noReturnType_parameters() {
+    createParser('Function(int, int)');
+    GenericFunctionType functionType = parser.parseTypeAnnotation(false);
+    expectNotNullIfNoErrors(functionType);
+    assertNoErrors();
+    expect(functionType.returnType, isNull);
+    expect(functionType.functionKeyword, isNotNull);
+    expect(functionType.typeParameters, isNull);
+    FormalParameterList parameterList = functionType.parameters;
+    expect(parameterList, isNotNull);
+    NodeList<FormalParameter> parameters = parameterList.parameters;
+    expect(parameters, hasLength(2));
+
+    expect(parameters[0], isSimpleFormalParameter);
+    SimpleFormalParameter parameter = parameters[0];
+    expect(parameter.identifier, isNull);
+    expect(parameter.type, isTypeName);
+    expect((parameter.type as TypeName).name.name, 'int');
+
+    expect(parameters[1], isSimpleFormalParameter);
+    parameter = parameters[1];
+    expect(parameter.identifier, isNull);
+    expect(parameter.type, isTypeName);
+    expect((parameter.type as TypeName).name.name, 'int');
+  }
+
+  void test_parseTypeAnnotation_function_noReturnType_typeParameters() {
+    createParser('Function<S, T>()');
+    GenericFunctionType functionType = parser.parseTypeAnnotation(false);
+    expectNotNullIfNoErrors(functionType);
+    assertNoErrors();
+    expect(functionType.returnType, isNull);
+    expect(functionType.functionKeyword, isNotNull);
+    TypeParameterList typeParameters = functionType.typeParameters;
+    expect(typeParameters, isNotNull);
+    expect(typeParameters.typeParameters, hasLength(2));
+    FormalParameterList parameterList = functionType.parameters;
+    expect(parameterList, isNotNull);
+    expect(parameterList.parameters, hasLength(0));
+  }
+
+  void
+      test_parseTypeAnnotation_function_noReturnType_typeParameters_parameters() {
+    createParser('Function<T>(String, {T t})');
+    GenericFunctionType functionType = parser.parseTypeAnnotation(false);
+    expectNotNullIfNoErrors(functionType);
+    assertNoErrors();
+    expect(functionType.returnType, isNull);
+    expect(functionType.functionKeyword, isNotNull);
+    TypeParameterList typeParameters = functionType.typeParameters;
+    expect(typeParameters, isNotNull);
+    expect(typeParameters.typeParameters, hasLength(1));
+    FormalParameterList parameterList = functionType.parameters;
+    expect(parameterList, isNotNull);
+    expect(parameterList.parameters, hasLength(2));
+  }
+
+  void test_parseTypeAnnotation_function_returnType_classFunction() {
+    createParser('Function');
+    TypeName functionType = parser.parseTypeAnnotation(false);
+    expectNotNullIfNoErrors(functionType);
+    assertNoErrors();
+  }
+
+  void test_parseTypeAnnotation_function_returnType_function() {
+    createParser('A Function(B, C) Function(D)');
+    // TODO(scheglov) improve the test to verify also the node properties
+    var functionType = parser.parseTypeAnnotation(false) as GenericFunctionType;
+    expectNotNullIfNoErrors(functionType);
+    assertNoErrors();
+  }
+
+  void test_parseTypeAnnotation_function_returnType_noParameters() {
+    createParser('List<int> Function()');
+    GenericFunctionType functionType = parser.parseTypeAnnotation(false);
+    expectNotNullIfNoErrors(functionType);
+    assertNoErrors();
+    expect(functionType.returnType, isNotNull);
+    expect(functionType.functionKeyword, isNotNull);
+    expect(functionType.typeParameters, isNull);
+    FormalParameterList parameterList = functionType.parameters;
+    expect(parameterList, isNotNull);
+    expect(parameterList.parameters, hasLength(0));
+  }
+
+  void test_parseTypeAnnotation_function_returnType_parameters() {
+    createParser('List<int> Function(String s, int i)');
+    GenericFunctionType functionType = parser.parseTypeAnnotation(false);
+    expectNotNullIfNoErrors(functionType);
+    assertNoErrors();
+    expect(functionType.returnType, isNotNull);
+    expect(functionType.functionKeyword, isNotNull);
+    expect(functionType.typeParameters, isNull);
+    FormalParameterList parameterList = functionType.parameters;
+    expect(parameterList, isNotNull);
+    NodeList<FormalParameter> parameters = parameterList.parameters;
+    expect(parameters, hasLength(2));
+
+    expect(parameters[0], isSimpleFormalParameter);
+    SimpleFormalParameter parameter = parameters[0];
+    expect(parameter.identifier, isNotNull);
+    expect(parameter.identifier.name, 's');
+    expect(parameter.type, isTypeName);
+    expect((parameter.type as TypeName).name.name, 'String');
+
+    expect(parameters[1], isSimpleFormalParameter);
+    parameter = parameters[1];
+    expect(parameter.identifier, isNotNull);
+    expect(parameter.identifier.name, 'i');
+    expect(parameter.type, isTypeName);
+    expect((parameter.type as TypeName).name.name, 'int');
+  }
+
+  void test_parseTypeAnnotation_function_returnType_simple() {
+    createParser('A Function(B, C)');
+    // TODO(scheglov) improve the test to verify also the node properties
+    var functionType = parser.parseTypeAnnotation(false) as GenericFunctionType;
+    expectNotNullIfNoErrors(functionType);
+    assertNoErrors();
+  }
+
+  void test_parseTypeAnnotation_function_returnType_typeParameters() {
+    createParser('List<T> Function<T>()');
+    GenericFunctionType functionType = parser.parseTypeAnnotation(false);
+    expectNotNullIfNoErrors(functionType);
+    assertNoErrors();
+    expect(functionType.returnType, isNotNull);
+    expect(functionType.functionKeyword, isNotNull);
+    TypeParameterList typeParameters = functionType.typeParameters;
+    expect(typeParameters, isNotNull);
+    expect(typeParameters.typeParameters, hasLength(1));
+    FormalParameterList parameterList = functionType.parameters;
+    expect(parameterList, isNotNull);
+    expect(parameterList.parameters, hasLength(0));
+  }
+
+  void
+      test_parseTypeAnnotation_function_returnType_typeParameters_parameters() {
+    createParser('List<T> Function<T>(String s, [T])');
+    GenericFunctionType functionType = parser.parseTypeAnnotation(false);
+    expectNotNullIfNoErrors(functionType);
+    assertNoErrors();
+    expect(functionType.returnType, isNotNull);
+    expect(functionType.functionKeyword, isNotNull);
+    TypeParameterList typeParameters = functionType.typeParameters;
+    expect(typeParameters, isNotNull);
+    expect(typeParameters.typeParameters, hasLength(1));
+    FormalParameterList parameterList = functionType.parameters;
+    expect(parameterList, isNotNull);
+    expect(parameterList.parameters, hasLength(2));
+  }
+
+  void test_parseTypeAnnotation_function_returnType_withArguments() {
+    createParser('A<B> Function(C)');
+    // TODO(scheglov) improve this test to verify also the node properties
+    var functionType = parser.parseTypeAnnotation(false) as GenericFunctionType;
+    expectNotNullIfNoErrors(functionType);
+    assertNoErrors();
+  }
+
+  void test_parseTypeAnnotation_named() {
+    createParser('A<B>');
+    TypeName typeName = parser.parseTypeAnnotation(false);
+    expectNotNullIfNoErrors(typeName);
+    assertNoErrors();
+  }
+
+  void test_parseTypeArgumentList_empty() {
+    createParser('<>');
+    TypeArgumentList argumentList = parser.parseTypeArgumentList();
+    expectNotNullIfNoErrors(argumentList);
+    listener.assertErrorsWithCodes([ParserErrorCode.EXPECTED_TYPE_NAME]);
+    expect(argumentList.leftBracket, isNotNull);
+    expect(argumentList.arguments, hasLength(1));
+    expect(argumentList.rightBracket, isNotNull);
+  }
+
+  void test_parseTypeArgumentList_multiple() {
+    createParser('<int, int, int>');
+    TypeArgumentList argumentList = parser.parseTypeArgumentList();
+    expectNotNullIfNoErrors(argumentList);
+    assertNoErrors();
+    expect(argumentList.leftBracket, isNotNull);
+    expect(argumentList.arguments, hasLength(3));
+    expect(argumentList.rightBracket, isNotNull);
+  }
+
+  void test_parseTypeArgumentList_nested() {
+    createParser('<A<B>>');
+    TypeArgumentList argumentList = parser.parseTypeArgumentList();
+    expectNotNullIfNoErrors(argumentList);
+    assertNoErrors();
+    expect(argumentList.leftBracket, isNotNull);
+    expect(argumentList.arguments, hasLength(1));
+    TypeName argument = argumentList.arguments[0];
+    expect(argument, isNotNull);
+    TypeArgumentList innerList = argument.typeArguments;
+    expect(innerList, isNotNull);
+    expect(innerList.arguments, hasLength(1));
+    expect(argumentList.rightBracket, isNotNull);
+  }
+
+  void test_parseTypeArgumentList_nested_withComment_double() {
+    createParser('<A<B /* 0 */ >>');
+    TypeArgumentList argumentList = parser.parseTypeArgumentList();
+    expectNotNullIfNoErrors(argumentList);
+    assertNoErrors();
+    expect(argumentList.leftBracket, isNotNull);
+    expect(argumentList.rightBracket, isNotNull);
+    expect(argumentList.arguments, hasLength(1));
+
+    TypeName argument = argumentList.arguments[0];
+    expect(argument, isNotNull);
+
+    TypeArgumentList innerList = argument.typeArguments;
+    expect(innerList, isNotNull);
+    expect(innerList.leftBracket, isNotNull);
+    expect(innerList.arguments, hasLength(1));
+    expect(innerList.rightBracket, isNotNull);
+    expect(innerList.rightBracket.precedingComments, isNotNull);
+  }
+
+  void test_parseTypeArgumentList_nested_withComment_tripple() {
+    createParser('<A<B<C /* 0 */ >>>');
+    TypeArgumentList argumentList = parser.parseTypeArgumentList();
+    expectNotNullIfNoErrors(argumentList);
+    assertNoErrors();
+    expect(argumentList.leftBracket, isNotNull);
+    expect(argumentList.rightBracket, isNotNull);
+    expect(argumentList.arguments, hasLength(1));
+
+    TypeName argument = argumentList.arguments[0];
+    expect(argument, isNotNull);
+
+    TypeArgumentList innerList = argument.typeArguments;
+    expect(innerList, isNotNull);
+    expect(innerList.leftBracket, isNotNull);
+    expect(innerList.arguments, hasLength(1));
+    expect(innerList.rightBracket, isNotNull);
+
+    TypeName innerArgument = innerList.arguments[0];
+    expect(innerArgument, isNotNull);
+
+    TypeArgumentList innerInnerList = innerArgument.typeArguments;
+    expect(innerInnerList, isNotNull);
+    expect(innerInnerList.leftBracket, isNotNull);
+    expect(innerInnerList.arguments, hasLength(1));
+    expect(innerInnerList.rightBracket, isNotNull);
+    expect(innerInnerList.rightBracket.precedingComments, isNotNull);
+  }
+
+  void test_parseTypeArgumentList_single() {
+    createParser('<int>');
+    TypeArgumentList argumentList = parser.parseTypeArgumentList();
+    expectNotNullIfNoErrors(argumentList);
+    assertNoErrors();
+    expect(argumentList.leftBracket, isNotNull);
+    expect(argumentList.arguments, hasLength(1));
+    expect(argumentList.rightBracket, isNotNull);
+  }
+
+  void test_parseTypeName_parameterized() {
+    createParser('List<int>');
+    TypeName typeName = parser.parseTypeName(false);
+    expectNotNullIfNoErrors(typeName);
+    assertNoErrors();
+    expect(typeName.name, isNotNull);
+    expect(typeName.typeArguments, isNotNull);
+  }
+
+  void test_parseTypeName_simple() {
+    createParser('int');
+    TypeName typeName = parser.parseTypeName(false);
+    expectNotNullIfNoErrors(typeName);
+    assertNoErrors();
+    expect(typeName.name, isNotNull);
+    expect(typeName.typeArguments, isNull);
+  }
+
+  void test_parseTypeParameter_bounded_functionType_noReturn() {
+    createParser('A extends Function(int)');
+    TypeParameter parameter = parser.parseTypeParameter();
+    expectNotNullIfNoErrors(parameter);
+    assertNoErrors();
+    expect(parameter.bound, isGenericFunctionType);
+    expect(parameter.extendsKeyword, isNotNull);
+    expect(parameter.name, isNotNull);
+  }
+
+  void test_parseTypeParameter_bounded_functionType_return() {
+    createParser('A extends String Function(int)');
+    TypeParameter parameter = parser.parseTypeParameter();
+    expectNotNullIfNoErrors(parameter);
+    assertNoErrors();
+    expect(parameter.bound, isGenericFunctionType);
+    expect(parameter.extendsKeyword, isNotNull);
+    expect(parameter.name, isNotNull);
+  }
+
+  void test_parseTypeParameter_bounded_generic() {
+    createParser('A extends B<C>');
+    TypeParameter parameter = parser.parseTypeParameter();
+    expectNotNullIfNoErrors(parameter);
+    assertNoErrors();
+    expect(parameter.bound, isTypeName);
+    expect(parameter.extendsKeyword, isNotNull);
+    expect(parameter.name, isNotNull);
+  }
+
+  void test_parseTypeParameter_bounded_simple() {
+    createParser('A extends B');
+    TypeParameter parameter = parser.parseTypeParameter();
+    expectNotNullIfNoErrors(parameter);
+    assertNoErrors();
+    expect(parameter.bound, isTypeName);
+    expect(parameter.extendsKeyword, isNotNull);
+    expect(parameter.name, isNotNull);
+  }
+
+  void test_parseTypeParameter_simple() {
+    createParser('A');
+    TypeParameter parameter = parser.parseTypeParameter();
+    expectNotNullIfNoErrors(parameter);
+    assertNoErrors();
+    expect(parameter.bound, isNull);
+    expect(parameter.extendsKeyword, isNull);
+    expect(parameter.name, isNotNull);
+  }
+
+  void test_parseTypeParameterList_multiple() {
+    createParser('<A, B extends C, D>');
+    TypeParameterList parameterList = parser.parseTypeParameterList();
+    expectNotNullIfNoErrors(parameterList);
+    assertNoErrors();
+    expect(parameterList.leftBracket, isNotNull);
+    expect(parameterList.rightBracket, isNotNull);
+    expect(parameterList.typeParameters, hasLength(3));
+  }
+
+  void test_parseTypeParameterList_parameterizedWithTrailingEquals() {
+    createParser('<A extends B<E>>=', expectedEndOffset: 16);
+    TypeParameterList parameterList = parser.parseTypeParameterList();
+    expectNotNullIfNoErrors(parameterList);
+    assertNoErrors();
+    expect(parameterList.leftBracket, isNotNull);
+    expect(parameterList.rightBracket, isNotNull);
+    expect(parameterList.typeParameters, hasLength(1));
+  }
+
+  void test_parseTypeParameterList_parameterizedWithTrailingEquals2() {
+    createParser('<A extends B<E /* foo */ >>=', expectedEndOffset: 27);
+    TypeParameterList parameterList = parser.parseTypeParameterList();
+    expectNotNullIfNoErrors(parameterList);
+    assertNoErrors();
+    expect(parameterList.leftBracket, isNotNull);
+    expect(parameterList.rightBracket, isNotNull);
+    expect(parameterList.typeParameters, hasLength(1));
+    TypeParameter typeParameter = parameterList.typeParameters[0];
+    expect(typeParameter.name.name, 'A');
+    TypeName bound = typeParameter.bound;
+    expect(bound.name.name, 'B');
+    TypeArgumentList typeArguments = bound.typeArguments;
+    expect(typeArguments.arguments, hasLength(1));
+    expect(typeArguments.rightBracket, isNotNull);
+    expect(typeArguments.rightBracket.precedingComments.lexeme, '/* foo */');
+    TypeName argument = typeArguments.arguments[0];
+    expect(argument.name.name, 'E');
+  }
+
+  void test_parseTypeParameterList_single() {
+    createParser('<<A>', expectedEndOffset: 0);
+    TypeParameterList parameterList = parser.parseTypeParameterList();
+    // TODO(danrubel): Consider splitting `<<` and marking the first `<`
+    // as an unexpected token.
+    expect(parameterList, isNull);
+    assertNoErrors();
+  }
+
+  void test_parseTypeParameterList_withTrailingEquals() {
+    createParser('<A>=', expectedEndOffset: 3);
+    TypeParameterList parameterList = parser.parseTypeParameterList();
+    expectNotNullIfNoErrors(parameterList);
+    assertNoErrors();
+    expect(parameterList.leftBracket, isNotNull);
+    expect(parameterList.rightBracket, isNotNull);
+    expect(parameterList.typeParameters, hasLength(1));
+  }
+
+  void test_parseVariableDeclaration_equals() {
+    VariableDeclaration declaration = parseVariableDeclaration('var a = b;');
+    expectNotNullIfNoErrors(declaration);
+    assertNoErrors();
+    expect(declaration.name, isNotNull);
+    expect(declaration.equals, isNotNull);
+    expect(declaration.initializer, isNotNull);
+  }
+
+  void test_parseVariableDeclaration_final_late() {
+    var statement = parseStatement('final late a;', featureSet: nonNullable)
+        as VariableDeclarationStatement;
+    var declarationList = statement.variables;
+    assertErrors(
+        errors: [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 6, 4)]);
+    expect(declarationList.keyword.lexeme, 'final');
+    expect(declarationList.type, isNull);
+    expect(declarationList.variables, hasLength(1));
+  }
+
+  void test_parseVariableDeclaration_late() {
+    var statement = parseStatement('late a;', featureSet: nonNullable)
+        as VariableDeclarationStatement;
+    var declarationList = statement.variables;
+    assertErrors(errors: [
+      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 5, 1)
+    ]);
+    expect(declarationList.keyword, isNull);
+    expect(declarationList.type, isNull);
+    expect(declarationList.variables, hasLength(1));
+  }
+
+  void test_parseVariableDeclaration_late_final() {
+    var statement = parseStatement('late final a;', featureSet: nonNullable)
+        as VariableDeclarationStatement;
+    var declarationList = statement.variables;
+    assertNoErrors();
+    expect(declarationList.keyword.lexeme, 'final');
+    expect(declarationList.type, isNull);
+    expect(declarationList.variables, hasLength(1));
+  }
+
+  void test_parseVariableDeclaration_late_init() {
+    var statement = parseStatement('late a = 0;', featureSet: nonNullable)
+        as VariableDeclarationStatement;
+    var declarationList = statement.variables;
+    assertErrors(errors: [
+      expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 5, 1)
+    ]);
+    expect(declarationList.keyword, isNull);
+    expect(declarationList.type, isNull);
+    expect(declarationList.variables, hasLength(1));
+  }
+
+  void test_parseVariableDeclaration_late_type() {
+    var statement = parseStatement('late A a;', featureSet: nonNullable)
+        as VariableDeclarationStatement;
+    var declarationList = statement.variables;
+    assertNoErrors();
+    expect(declarationList.lateKeyword, isNotNull);
+    expect(declarationList.keyword, isNull);
+    expect(declarationList.type, isNotNull);
+    expect(declarationList.variables, hasLength(1));
+  }
+
+  void test_parseVariableDeclaration_late_var() {
+    var statement = parseStatement('late var a;', featureSet: nonNullable)
+        as VariableDeclarationStatement;
+    var declarationList = statement.variables;
+    assertNoErrors();
+    expect(declarationList.lateKeyword, isNotNull);
+    expect(declarationList.keyword?.lexeme, 'var');
+    expect(declarationList.type, isNull);
+    expect(declarationList.variables, hasLength(1));
+  }
+
+  void test_parseVariableDeclaration_late_var_init() {
+    var statement = parseStatement('late var a = 0;', featureSet: nonNullable)
+        as VariableDeclarationStatement;
+    var declarationList = statement.variables;
+    assertNoErrors();
+    expect(declarationList.lateKeyword, isNotNull);
+    expect(declarationList.keyword?.lexeme, 'var');
+    expect(declarationList.type, isNull);
+    expect(declarationList.variables, hasLength(1));
+  }
+
+  void test_parseVariableDeclaration_noEquals() {
+    VariableDeclaration declaration = parseVariableDeclaration('var a;');
+    expectNotNullIfNoErrors(declaration);
+    assertNoErrors();
+    expect(declaration.name, isNotNull);
+    expect(declaration.equals, isNull);
+    expect(declaration.initializer, isNull);
+  }
+
+  void test_parseWithClause_multiple() {
+    WithClause clause = parseWithClause('with A, B, C');
+    expectNotNullIfNoErrors(clause);
+    assertNoErrors();
+    expect(clause.withKeyword, isNotNull);
+    expect(clause.mixinTypes, hasLength(3));
+  }
+
+  void test_parseWithClause_single() {
+    WithClause clause = parseWithClause('with M');
+    expectNotNullIfNoErrors(clause);
+    assertNoErrors();
+    expect(clause.withKeyword, isNotNull);
+    expect(clause.mixinTypes, hasLength(1));
+  }
+
+  void test_typeAlias_37733() {
+    // https://github.com/dart-lang/sdk/issues/37733
+    var unit = parseCompilationUnit(r'typedef K=Function(<>($', errors: [
+      expectedError(CompileTimeErrorCode.INVALID_INLINE_FUNCTION_TYPE, 19, 1),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 19, 1),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 20, 1),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 22, 1),
+      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 23, 1),
+      expectedError(ScannerErrorCode.EXPECTED_TOKEN, 23, 1),
+    ]);
+    var typeAlias = unit.declarations[0] as GenericTypeAlias;
+    expect(typeAlias.name.toSource(), 'K');
+    var functionType = typeAlias.functionType;
+    expect(functionType.parameters.parameters, hasLength(1));
+    var parameter = functionType.parameters.parameters[0];
+    expect(parameter.identifier, isNotNull);
+  }
+
+  void test_typeAlias_parameter_missingIdentifier_37733() {
+    // https://github.com/dart-lang/sdk/issues/37733
+    var unit = parseCompilationUnit(r'typedef T=Function(<S>());', errors: [
+      expectedError(CompileTimeErrorCode.INVALID_INLINE_FUNCTION_TYPE, 19, 1),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 19, 1),
+    ]);
+    var typeAlias = unit.declarations[0] as GenericTypeAlias;
+    expect(typeAlias.name.toSource(), 'T');
+    var functionType = typeAlias.functionType;
+    expect(functionType.parameters.parameters, hasLength(1));
+    var parameter = functionType.parameters.parameters[0];
+    expect(parameter.identifier, isNotNull);
+  }
+}
diff --git a/pkg/analyzer/test/generated/statement_parser_test.dart b/pkg/analyzer/test/generated/statement_parser_test.dart
new file mode 100644
index 0000000..1907c1b
--- /dev/null
+++ b/pkg/analyzer/test/generated/statement_parser_test.dart
@@ -0,0 +1,1775 @@
+// Copyright (c) 2020, 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.
+
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart' as analyzer;
+import 'package:analyzer/dart/ast/token.dart' show TokenType;
+import 'package:analyzer/src/dart/scanner/scanner.dart';
+import 'package:analyzer/src/error/codes.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../util/ast_type_matchers.dart';
+import 'parser_test_base.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(StatementParserTest);
+  });
+}
+
+/// Tests of the fasta parser based on [StatementParserTestMixin].
+@reflectiveTest
+class StatementParserTest extends FastaParserTestCase {
+  void test_35177() {
+    ExpressionStatement statement = parseStatement('(f)()<int>();');
+
+    FunctionExpressionInvocation funct1 = statement.expression;
+    NodeList<TypeAnnotation> typeArgs = funct1.typeArguments.arguments;
+    expect(typeArgs, hasLength(1));
+    TypeName typeName = typeArgs[0];
+    expect(typeName.name.name, 'int');
+    expect(funct1.argumentList.arguments, hasLength(0));
+
+    FunctionExpressionInvocation funct2 = funct1.function;
+    expect(funct2.typeArguments, isNull);
+    expect(funct2.argumentList.arguments, hasLength(0));
+
+    ParenthesizedExpression expression = funct2.function;
+    SimpleIdentifier identifier = expression.expression;
+    expect(identifier.name, 'f');
+  }
+
+  void test_invalid_typeArg_34850() {
+    var unit = parseCompilationUnit('foo Future<List<int>> bar() {}', errors: [
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 11, 4),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 4, 6),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 22, 3),
+    ]);
+    // Validate that recovery has properly updated the token stream.
+    analyzer.Token token = unit.beginToken;
+    while (!token.isEof) {
+      expect(token.type, isNot(TokenType.GT_GT));
+      analyzer.Token next = token.next;
+      expect(next.previous, token);
+      token = next;
+    }
+  }
+
+  void test_invalid_typeParamAnnotation() {
+    parseCompilationUnit('main() { C<@Foo T> v; }', errors: [
+      expectedError(ParserErrorCode.ANNOTATION_ON_TYPE_ARGUMENT, 11, 4)
+    ]);
+  }
+
+  void test_invalid_typeParamAnnotation2() {
+    parseCompilationUnit('main() { C<@Foo.bar(1) T> v; }', errors: [
+      expectedError(ParserErrorCode.ANNOTATION_ON_TYPE_ARGUMENT, 11, 11)
+    ]);
+  }
+
+  void test_invalid_typeParamAnnotation3() {
+    parseCompilationUnit('''
+main() {
+  C<@Foo.bar(const [], const [1], const{"":r""}, 0xFF + 2, .3, 4.5) T,
+    F Function<G>(int, String, {Bar b}),
+    void Function<H>(int i, [String j, K]),
+    A<B<C>>,
+    W<X<Y<Z>>>
+  > v;
+}''', errors: [
+      expectedError(ParserErrorCode.ANNOTATION_ON_TYPE_ARGUMENT, 13, 63)
+    ]);
+  }
+
+  void test_parseAssertStatement() {
+    var statement = parseStatement('assert (x);') as AssertStatement;
+    assertNoErrors();
+    expect(statement.assertKeyword, isNotNull);
+    expect(statement.leftParenthesis, isNotNull);
+    expect(statement.condition, isNotNull);
+    expect(statement.comma, isNull);
+    expect(statement.message, isNull);
+    expect(statement.rightParenthesis, isNotNull);
+    expect(statement.semicolon, isNotNull);
+  }
+
+  void test_parseAssertStatement_messageLowPrecedence() {
+    // Using a throw expression as an assert message would be silly in
+    // practice, but it's the lowest precedence expression type, so verifying
+    // that it works should give us high confidence that other expression types
+    // will work as well.
+    var statement =
+        parseStatement('assert (x, throw "foo");') as AssertStatement;
+    assertNoErrors();
+    expect(statement.assertKeyword, isNotNull);
+    expect(statement.leftParenthesis, isNotNull);
+    expect(statement.condition, isNotNull);
+    expect(statement.comma, isNotNull);
+    expect(statement.message, isNotNull);
+    expect(statement.rightParenthesis, isNotNull);
+    expect(statement.semicolon, isNotNull);
+  }
+
+  void test_parseAssertStatement_messageString() {
+    var statement = parseStatement('assert (x, "foo");') as AssertStatement;
+    assertNoErrors();
+    expect(statement.assertKeyword, isNotNull);
+    expect(statement.leftParenthesis, isNotNull);
+    expect(statement.condition, isNotNull);
+    expect(statement.comma, isNotNull);
+    expect(statement.message, isNotNull);
+    expect(statement.rightParenthesis, isNotNull);
+    expect(statement.semicolon, isNotNull);
+  }
+
+  void test_parseAssertStatement_trailingComma_message() {
+    var statement = parseStatement('assert (x, "m",);') as AssertStatement;
+    assertNoErrors();
+    expect(statement.assertKeyword, isNotNull);
+    expect(statement.leftParenthesis, isNotNull);
+    expect(statement.condition, isNotNull);
+    expect(statement.comma, isNotNull);
+    expect(statement.message, isNotNull);
+    expect(statement.rightParenthesis, isNotNull);
+    expect(statement.semicolon, isNotNull);
+  }
+
+  void test_parseAssertStatement_trailingComma_noMessage() {
+    var statement = parseStatement('assert (x,);') as AssertStatement;
+    assertNoErrors();
+    expect(statement.assertKeyword, isNotNull);
+    expect(statement.leftParenthesis, isNotNull);
+    expect(statement.condition, isNotNull);
+    expect(statement.comma, isNull);
+    expect(statement.message, isNull);
+    expect(statement.rightParenthesis, isNotNull);
+    expect(statement.semicolon, isNotNull);
+  }
+
+  void test_parseBlock_empty() {
+    var block = parseStatement('{}') as Block;
+    assertNoErrors();
+    expect(block.leftBracket, isNotNull);
+    expect(block.statements, hasLength(0));
+    expect(block.rightBracket, isNotNull);
+  }
+
+  void test_parseBlock_nonEmpty() {
+    var block = parseStatement('{;}') as Block;
+    assertNoErrors();
+    expect(block.leftBracket, isNotNull);
+    expect(block.statements, hasLength(1));
+    expect(block.rightBracket, isNotNull);
+  }
+
+  void test_parseBreakStatement_label() {
+    LabeledStatement labeledStatement =
+        parseStatement('foo: while (true) { break foo; }');
+    WhileStatement whileStatement = labeledStatement.statement;
+    BreakStatement statement = (whileStatement.body as Block).statements[0];
+    assertNoErrors();
+    expect(statement.breakKeyword, isNotNull);
+    expect(statement.label, isNotNull);
+    expect(statement.semicolon, isNotNull);
+  }
+
+  void test_parseBreakStatement_noLabel() {
+    WhileStatement whileStatement = parseStatement('while (true) { break; }');
+    BreakStatement statement = (whileStatement.body as Block).statements[0];
+    assertNoErrors();
+    expect(statement.breakKeyword, isNotNull);
+    expect(statement.label, isNull);
+    expect(statement.semicolon, isNotNull);
+  }
+
+  void test_parseContinueStatement_label() {
+    LabeledStatement labeledStatement =
+        parseStatement('foo: while (true) { continue foo; }');
+    WhileStatement whileStatement = labeledStatement.statement;
+    ContinueStatement statement = (whileStatement.body as Block).statements[0];
+    assertNoErrors();
+    expect(statement.continueKeyword, isNotNull);
+    expect(statement.label, isNotNull);
+    expect(statement.semicolon, isNotNull);
+  }
+
+  void test_parseContinueStatement_noLabel() {
+    WhileStatement whileStatement =
+        parseStatement('while (true) { continue; }');
+    ContinueStatement statement = (whileStatement.body as Block).statements[0];
+    assertNoErrors();
+    expect(statement.continueKeyword, isNotNull);
+    expect(statement.label, isNull);
+    expect(statement.semicolon, isNotNull);
+  }
+
+  void test_parseDoStatement() {
+    var statement = parseStatement('do {} while (x);') as DoStatement;
+    assertNoErrors();
+    expect(statement.doKeyword, isNotNull);
+    expect(statement.body, isNotNull);
+    expect(statement.whileKeyword, isNotNull);
+    expect(statement.leftParenthesis, isNotNull);
+    expect(statement.condition, isNotNull);
+    expect(statement.rightParenthesis, isNotNull);
+    expect(statement.semicolon, isNotNull);
+  }
+
+  void test_parseElseAlone() {
+    parseCompilationUnit('main() { else return 0; } ', errors: [
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 9, 4),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 9, 4),
+      expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 9, 4),
+    ]);
+  }
+
+  void test_parseEmptyStatement() {
+    var statement = parseStatement(';') as EmptyStatement;
+    assertNoErrors();
+    expect(statement.semicolon, isNotNull);
+  }
+
+  void test_parseForStatement_each_await() {
+    // TODO(danrubel): remove this once control flow and spread collection
+    // entry parsing is enabled by default
+    String code = 'await for (element in list) {}';
+    var forStatement = _parseAsyncStatement(code) as ForStatement;
+    assertNoErrors();
+    expect(forStatement.awaitKeyword, isNotNull);
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    var forEachParts = forStatement.forLoopParts as ForEachPartsWithIdentifier;
+    expect(forEachParts.identifier, isNotNull);
+    expect(forEachParts.inKeyword, isNotNull);
+    expect(forEachParts.iterable, isNotNull);
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_each_await2() {
+    ForStatement forStatement = parseStatement(
+      'await for (element in list) {}',
+      inAsync: true,
+      featureSet: controlFlow,
+    );
+    assertNoErrors();
+    expect(forStatement.awaitKeyword, isNotNull);
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    ForEachPartsWithIdentifier forLoopParts = forStatement.forLoopParts;
+    expect(forLoopParts.identifier, isNotNull);
+    expect(forLoopParts.inKeyword, isNotNull);
+    expect(forLoopParts.iterable, isNotNull);
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_each_finalExternal() {
+    ForStatement forStatement = parseStatement(
+      'for (final external in list) {}',
+      featureSet: controlFlow,
+    );
+    assertNoErrors();
+    expect(forStatement.awaitKeyword, isNull);
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    ForEachPartsWithDeclaration forLoopParts = forStatement.forLoopParts;
+    expect(forLoopParts.loopVariable.identifier.name, 'external');
+    expect(forLoopParts.inKeyword, isNotNull);
+    expect(forLoopParts.iterable, isNotNull);
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_each_finalRequired() {
+    ForStatement forStatement = parseStatement(
+      'for (final required in list) {}',
+      featureSet: controlFlow,
+    );
+    assertNoErrors();
+    expect(forStatement.awaitKeyword, isNull);
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    ForEachPartsWithDeclaration forLoopParts = forStatement.forLoopParts;
+    expect(forLoopParts.loopVariable.identifier.name, 'required');
+    expect(forLoopParts.inKeyword, isNotNull);
+    expect(forLoopParts.iterable, isNotNull);
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_each_genericFunctionType() {
+    // TODO(danrubel): remove this once control flow and spread collection
+    // entry parsing is enabled by default
+    var forStatement =
+        parseStatement('for (void Function<T>(T) element in list) {}')
+            as ForStatement;
+    assertNoErrors();
+    expect(forStatement.awaitKeyword, isNull);
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    var forEachParts = forStatement.forLoopParts as ForEachPartsWithDeclaration;
+    expect(forEachParts.loopVariable, isNotNull);
+    expect(forEachParts.inKeyword, isNotNull);
+    expect(forEachParts.iterable, isNotNull);
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_each_genericFunctionType2() {
+    ForStatement forStatement = parseStatement(
+      'for (void Function<T>(T) element in list) {}',
+      featureSet: controlFlow,
+    );
+    assertNoErrors();
+    expect(forStatement.awaitKeyword, isNull);
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    ForEachPartsWithDeclaration forLoopParts = forStatement.forLoopParts;
+    expect(forLoopParts.loopVariable, isNotNull);
+    expect(forLoopParts.inKeyword, isNotNull);
+    expect(forLoopParts.iterable, isNotNull);
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_each_identifier() {
+    // TODO(danrubel): remove this once control flow and spread collection
+    // entry parsing is enabled by default
+    var forStatement =
+        parseStatement('for (element in list) {}') as ForStatement;
+    assertNoErrors();
+    expect(forStatement.awaitKeyword, isNull);
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    var forEachParts = forStatement.forLoopParts as ForEachPartsWithIdentifier;
+    expect(forEachParts.identifier, isNotNull);
+    expect(forEachParts.inKeyword, isNotNull);
+    expect(forEachParts.iterable, isNotNull);
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_each_identifier2() {
+    ForStatement forStatement = parseStatement(
+      'for (element in list) {}',
+      featureSet: controlFlow,
+    );
+    assertNoErrors();
+    expect(forStatement.awaitKeyword, isNull);
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    ForEachPartsWithIdentifier forLoopParts = forStatement.forLoopParts;
+    expect(forLoopParts.identifier, isNotNull);
+    expect(forLoopParts.inKeyword, isNotNull);
+    expect(forLoopParts.iterable, isNotNull);
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_each_noType_metadata() {
+    // TODO(danrubel): remove this once control flow and spread collection
+    // entry parsing is enabled by default
+    var forStatement =
+        parseStatement('for (@A var element in list) {}') as ForStatement;
+    assertNoErrors();
+    expect(forStatement.awaitKeyword, isNull);
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    var forEachParts = forStatement.forLoopParts as ForEachPartsWithDeclaration;
+    expect(forEachParts.loopVariable, isNotNull);
+    expect(forEachParts.loopVariable.metadata, hasLength(1));
+    expect(forEachParts.inKeyword, isNotNull);
+    expect(forEachParts.iterable, isNotNull);
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_each_noType_metadata2() {
+    ForStatement forStatement = parseStatement(
+      'for (@A var element in list) {}',
+      featureSet: controlFlow,
+    );
+    assertNoErrors();
+    expect(forStatement.awaitKeyword, isNull);
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    ForEachPartsWithDeclaration forLoopParts = forStatement.forLoopParts;
+    expect(forLoopParts.loopVariable, isNotNull);
+    expect(forLoopParts.loopVariable.metadata, hasLength(1));
+    expect(forLoopParts.inKeyword, isNotNull);
+    expect(forLoopParts.iterable, isNotNull);
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_each_type() {
+    // TODO(danrubel): remove this once control flow and spread collection
+    // entry parsing is enabled by default
+    var forStatement =
+        parseStatement('for (A element in list) {}') as ForStatement;
+    assertNoErrors();
+    expect(forStatement.awaitKeyword, isNull);
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    var forEachParts = forStatement.forLoopParts as ForEachPartsWithDeclaration;
+    expect(forEachParts.loopVariable, isNotNull);
+    expect(forEachParts.inKeyword, isNotNull);
+    expect(forEachParts.iterable, isNotNull);
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_each_type2() {
+    ForStatement forStatement = parseStatement(
+      'for (A element in list) {}',
+      featureSet: controlFlow,
+    );
+    assertNoErrors();
+    expect(forStatement.awaitKeyword, isNull);
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    ForEachPartsWithDeclaration forLoopParts = forStatement.forLoopParts;
+    expect(forLoopParts.loopVariable, isNotNull);
+    expect(forLoopParts.inKeyword, isNotNull);
+    expect(forLoopParts.iterable, isNotNull);
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_each_var() {
+    // TODO(danrubel): remove this once control flow and spread collection
+    // entry parsing is enabled by default
+    var forStatement =
+        parseStatement('for (var element in list) {}') as ForStatement;
+    assertNoErrors();
+    expect(forStatement.awaitKeyword, isNull);
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    var forEachParts = forStatement.forLoopParts as ForEachPartsWithDeclaration;
+    expect(forEachParts.loopVariable, isNotNull);
+    expect(forEachParts.inKeyword, isNotNull);
+    expect(forEachParts.iterable, isNotNull);
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_each_var2() {
+    ForStatement forStatement = parseStatement(
+      'for (var element in list) {}',
+      featureSet: controlFlow,
+    );
+    assertNoErrors();
+    expect(forStatement.awaitKeyword, isNull);
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    ForEachPartsWithDeclaration forLoopParts = forStatement.forLoopParts;
+    expect(forLoopParts.loopVariable, isNotNull);
+    expect(forLoopParts.inKeyword, isNotNull);
+    expect(forLoopParts.iterable, isNotNull);
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_loop_c() {
+    // TODO(danrubel): remove this once control flow and spread collection
+    // entry parsing is enabled by default
+    var forStatement = parseStatement('for (; i < count;) {}') as ForStatement;
+    assertNoErrors();
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    var forParts = forStatement.forLoopParts as ForPartsWithExpression;
+    expect(forParts.initialization, isNull);
+    expect(forParts.leftSeparator, isNotNull);
+    expect(forParts.condition, isNotNull);
+    expect(forParts.rightSeparator, isNotNull);
+    expect(forParts.updaters, hasLength(0));
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_loop_c2() {
+    ForStatement forStatement = parseStatement(
+      'for (; i < count;) {}',
+      featureSet: controlFlow,
+    );
+    assertNoErrors();
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    ForPartsWithExpression forLoopParts = forStatement.forLoopParts;
+    expect(forLoopParts.initialization, isNull);
+    expect(forLoopParts.leftSeparator, isNotNull);
+    expect(forLoopParts.condition, isNotNull);
+    expect(forLoopParts.rightSeparator, isNotNull);
+    expect(forLoopParts.updaters, hasLength(0));
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_loop_cu() {
+    // TODO(danrubel): remove this once control flow and spread collection
+    // entry parsing is enabled by default
+    var forStatement =
+        parseStatement('for (; i < count; i++) {}') as ForStatement;
+    assertNoErrors();
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    var forParts = forStatement.forLoopParts as ForPartsWithExpression;
+    expect(forParts.initialization, isNull);
+    expect(forParts.leftSeparator, isNotNull);
+    expect(forParts.condition, isNotNull);
+    expect(forParts.rightSeparator, isNotNull);
+    expect(forParts.updaters, hasLength(1));
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_loop_cu2() {
+    ForStatement forStatement = parseStatement(
+      'for (; i < count; i++) {}',
+      featureSet: controlFlow,
+    );
+    assertNoErrors();
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    ForPartsWithExpression forLoopParts = forStatement.forLoopParts;
+    expect(forLoopParts.initialization, isNull);
+    expect(forLoopParts.leftSeparator, isNotNull);
+    expect(forLoopParts.condition, isNotNull);
+    expect(forLoopParts.rightSeparator, isNotNull);
+    expect(forLoopParts.updaters, hasLength(1));
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_loop_ecu() {
+    // TODO(danrubel): remove this once control flow and spread collection
+    // entry parsing is enabled by default
+    var forStatement =
+        parseStatement('for (i--; i < count; i++) {}') as ForStatement;
+    assertNoErrors();
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    var forParts = forStatement.forLoopParts as ForPartsWithExpression;
+    expect(forParts.initialization, isNotNull);
+    expect(forParts.leftSeparator, isNotNull);
+    expect(forParts.condition, isNotNull);
+    expect(forParts.rightSeparator, isNotNull);
+    expect(forParts.updaters, hasLength(1));
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_loop_ecu2() {
+    ForStatement forStatement = parseStatement(
+      'for (i--; i < count; i++) {}',
+      featureSet: spread,
+    );
+    assertNoErrors();
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    ForPartsWithExpression forLoopParts = forStatement.forLoopParts;
+    expect(forLoopParts.initialization, isNotNull);
+    expect(forLoopParts.leftSeparator, isNotNull);
+    expect(forLoopParts.condition, isNotNull);
+    expect(forLoopParts.rightSeparator, isNotNull);
+    expect(forLoopParts.updaters, hasLength(1));
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_loop_i() {
+    // TODO(danrubel): remove this once control flow and spread collection
+    // entry parsing is enabled by default
+    var forStatement = parseStatement('for (var i = 0;;) {}') as ForStatement;
+    assertNoErrors();
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    var forParts = forStatement.forLoopParts as ForPartsWithDeclarations;
+    VariableDeclarationList variables = forParts.variables;
+    expect(variables, isNotNull);
+    expect(variables.metadata, hasLength(0));
+    expect(variables.variables, hasLength(1));
+    expect(forParts.leftSeparator, isNotNull);
+    expect(forParts.condition, isNull);
+    expect(forParts.rightSeparator, isNotNull);
+    expect(forParts.updaters, hasLength(0));
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_loop_i2() {
+    ForStatement forStatement = parseStatement(
+      'for (var i = 0;;) {}',
+      featureSet: spread,
+    );
+    assertNoErrors();
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    ForPartsWithDeclarations forLoopParts = forStatement.forLoopParts;
+    VariableDeclarationList variables = forLoopParts.variables;
+    expect(variables, isNotNull);
+    expect(variables.metadata, hasLength(0));
+    expect(variables.variables, hasLength(1));
+    expect(forLoopParts.leftSeparator, isNotNull);
+    expect(forLoopParts.condition, isNull);
+    expect(forLoopParts.rightSeparator, isNotNull);
+    expect(forLoopParts.updaters, hasLength(0));
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_loop_i_withMetadata() {
+    // TODO(danrubel): remove this once control flow and spread collection
+    // entry parsing is enabled by default
+    var forStatement =
+        parseStatement('for (@A var i = 0;;) {}') as ForStatement;
+    assertNoErrors();
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    var forParts = forStatement.forLoopParts as ForPartsWithDeclarations;
+    VariableDeclarationList variables = forParts.variables;
+    expect(variables, isNotNull);
+    expect(variables.metadata, hasLength(1));
+    expect(variables.variables, hasLength(1));
+    expect(forParts.leftSeparator, isNotNull);
+    expect(forParts.condition, isNull);
+    expect(forParts.rightSeparator, isNotNull);
+    expect(forParts.updaters, hasLength(0));
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_loop_i_withMetadata2() {
+    ForStatement forStatement = parseStatement(
+      'for (@A var i = 0;;) {}',
+      featureSet: spread,
+    );
+    assertNoErrors();
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    ForPartsWithDeclarations forLoopParts = forStatement.forLoopParts;
+    VariableDeclarationList variables = forLoopParts.variables;
+    expect(variables, isNotNull);
+    expect(variables.metadata, hasLength(1));
+    expect(variables.variables, hasLength(1));
+    expect(forLoopParts.leftSeparator, isNotNull);
+    expect(forLoopParts.condition, isNull);
+    expect(forLoopParts.rightSeparator, isNotNull);
+    expect(forLoopParts.updaters, hasLength(0));
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_loop_ic() {
+    // TODO(danrubel): remove this once control flow and spread collection
+    // entry parsing is enabled by default
+    var forStatement =
+        parseStatement('for (var i = 0; i < count;) {}') as ForStatement;
+    assertNoErrors();
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    var forParts = forStatement.forLoopParts as ForPartsWithDeclarations;
+    VariableDeclarationList variables = forParts.variables;
+    expect(variables, isNotNull);
+    expect(variables.variables, hasLength(1));
+    expect(forParts.leftSeparator, isNotNull);
+    expect(forParts.condition, isNotNull);
+    expect(forParts.rightSeparator, isNotNull);
+    expect(forParts.updaters, hasLength(0));
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_loop_ic2() {
+    ForStatement forStatement = parseStatement(
+      'for (var i = 0; i < count;) {}',
+      featureSet: spread,
+    );
+    assertNoErrors();
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    ForPartsWithDeclarations forLoopParts = forStatement.forLoopParts;
+    VariableDeclarationList variables = forLoopParts.variables;
+    expect(variables, isNotNull);
+    expect(variables.variables, hasLength(1));
+    expect(forLoopParts.leftSeparator, isNotNull);
+    expect(forLoopParts.condition, isNotNull);
+    expect(forLoopParts.rightSeparator, isNotNull);
+    expect(forLoopParts.updaters, hasLength(0));
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_loop_icu() {
+    // TODO(danrubel): remove this once control flow and spread collection
+    // entry parsing is enabled by default
+    var forStatement =
+        parseStatement('for (var i = 0; i < count; i++) {}') as ForStatement;
+    assertNoErrors();
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    var forParts = forStatement.forLoopParts as ForPartsWithDeclarations;
+    VariableDeclarationList variables = forParts.variables;
+    expect(variables, isNotNull);
+    expect(variables.variables, hasLength(1));
+    expect(forParts.leftSeparator, isNotNull);
+    expect(forParts.condition, isNotNull);
+    expect(forParts.rightSeparator, isNotNull);
+    expect(forParts.updaters, hasLength(1));
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_loop_icu2() {
+    ForStatement forStatement = parseStatement(
+      'for (var i = 0; i < count; i++) {}',
+      featureSet: spread,
+    );
+    assertNoErrors();
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    ForPartsWithDeclarations forLoopParts = forStatement.forLoopParts;
+    VariableDeclarationList variables = forLoopParts.variables;
+    expect(variables, isNotNull);
+    expect(variables.variables, hasLength(1));
+    expect(forLoopParts.leftSeparator, isNotNull);
+    expect(forLoopParts.condition, isNotNull);
+    expect(forLoopParts.rightSeparator, isNotNull);
+    expect(forLoopParts.updaters, hasLength(1));
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_loop_iicuu() {
+    // TODO(danrubel): remove this once control flow and spread collection
+    // entry parsing is enabled by default
+    var forStatement =
+        parseStatement('for (int i = 0, j = count; i < j; i++, j--) {}')
+            as ForStatement;
+    assertNoErrors();
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    var forParts = forStatement.forLoopParts as ForPartsWithDeclarations;
+    VariableDeclarationList variables = forParts.variables;
+    expect(variables, isNotNull);
+    expect(variables.variables, hasLength(2));
+    expect(forParts.leftSeparator, isNotNull);
+    expect(forParts.condition, isNotNull);
+    expect(forParts.rightSeparator, isNotNull);
+    expect(forParts.updaters, hasLength(2));
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_loop_iicuu2() {
+    ForStatement forStatement = parseStatement(
+      'for (int i = 0, j = count; i < j; i++, j--) {}',
+      featureSet: spread,
+    );
+    assertNoErrors();
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    ForPartsWithDeclarations forLoopParts = forStatement.forLoopParts;
+    VariableDeclarationList variables = forLoopParts.variables;
+    expect(variables, isNotNull);
+    expect(variables.variables, hasLength(2));
+    expect(forLoopParts.leftSeparator, isNotNull);
+    expect(forLoopParts.condition, isNotNull);
+    expect(forLoopParts.rightSeparator, isNotNull);
+    expect(forLoopParts.updaters, hasLength(2));
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_loop_iu() {
+    // TODO(danrubel): remove this once control flow and spread collection
+    // entry parsing is enabled by default
+    var forStatement =
+        parseStatement('for (var i = 0;; i++) {}') as ForStatement;
+    assertNoErrors();
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    var forParts = forStatement.forLoopParts as ForPartsWithDeclarations;
+    VariableDeclarationList variables = forParts.variables;
+    expect(variables, isNotNull);
+    expect(variables.variables, hasLength(1));
+    expect(forParts.leftSeparator, isNotNull);
+    expect(forParts.condition, isNull);
+    expect(forParts.rightSeparator, isNotNull);
+    expect(forParts.updaters, hasLength(1));
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_loop_iu2() {
+    ForStatement forStatement = parseStatement(
+      'for (var i = 0;; i++) {}',
+      featureSet: spread,
+    );
+    assertNoErrors();
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    ForPartsWithDeclarations forLoopParts = forStatement.forLoopParts;
+    VariableDeclarationList variables = forLoopParts.variables;
+    expect(variables, isNotNull);
+    expect(variables.variables, hasLength(1));
+    expect(forLoopParts.leftSeparator, isNotNull);
+    expect(forLoopParts.condition, isNull);
+    expect(forLoopParts.rightSeparator, isNotNull);
+    expect(forLoopParts.updaters, hasLength(1));
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_loop_u() {
+    // TODO(danrubel): remove this once control flow and spread collection
+    // entry parsing is enabled by default
+    var forStatement = parseStatement('for (;; i++) {}') as ForStatement;
+    assertNoErrors();
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    var forParts = forStatement.forLoopParts as ForPartsWithExpression;
+    expect(forParts.initialization, isNull);
+    expect(forParts.leftSeparator, isNotNull);
+    expect(forParts.condition, isNull);
+    expect(forParts.rightSeparator, isNotNull);
+    expect(forParts.updaters, hasLength(1));
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseForStatement_loop_u2() {
+    ForStatement forStatement = parseStatement(
+      'for (;; i++) {}',
+      featureSet: spread,
+    );
+    assertNoErrors();
+    expect(forStatement.forKeyword, isNotNull);
+    expect(forStatement.leftParenthesis, isNotNull);
+    ForPartsWithExpression forLoopParts = forStatement.forLoopParts;
+    expect(forLoopParts.initialization, isNull);
+    expect(forLoopParts.leftSeparator, isNotNull);
+    expect(forLoopParts.condition, isNull);
+    expect(forLoopParts.rightSeparator, isNotNull);
+    expect(forLoopParts.updaters, hasLength(1));
+    expect(forStatement.rightParenthesis, isNotNull);
+    expect(forStatement.body, isNotNull);
+  }
+
+  void test_parseFunctionDeclarationStatement() {
+    var statement = parseStatement('void f(int p) => p * 2;')
+        as FunctionDeclarationStatement;
+    assertNoErrors();
+    expect(statement.functionDeclaration, isNotNull);
+  }
+
+  void test_parseFunctionDeclarationStatement_typeParameters() {
+    var statement =
+        parseStatement('E f<E>(E p) => p * 2;') as FunctionDeclarationStatement;
+    assertNoErrors();
+    expect(statement.functionDeclaration, isNotNull);
+    expect(statement.functionDeclaration.functionExpression.typeParameters,
+        isNotNull);
+  }
+
+  void test_parseFunctionDeclarationStatement_typeParameters_noReturnType() {
+    var statement =
+        parseStatement('f<E>(E p) => p * 2;') as FunctionDeclarationStatement;
+    assertNoErrors();
+    expect(statement.functionDeclaration, isNotNull);
+    expect(statement.functionDeclaration.functionExpression.typeParameters,
+        isNotNull);
+  }
+
+  void test_parseIfStatement_else_block() {
+    var statement = parseStatement('if (x) {} else {}') as IfStatement;
+    assertNoErrors();
+    expect(statement.ifKeyword, isNotNull);
+    expect(statement.leftParenthesis, isNotNull);
+    expect(statement.condition, isNotNull);
+    expect(statement.rightParenthesis, isNotNull);
+    expect(statement.thenStatement, isNotNull);
+    expect(statement.elseKeyword, isNotNull);
+    expect(statement.elseStatement, isNotNull);
+  }
+
+  void test_parseIfStatement_else_emptyStatements() {
+    var statement = parseStatement('if (true) ; else ;') as IfStatement;
+    assertNoErrors();
+    expect(statement.ifKeyword, isNotNull);
+    expect(statement.leftParenthesis, isNotNull);
+    expect(statement.condition, isNotNull);
+    expect(statement.rightParenthesis, isNotNull);
+    expect(statement.thenStatement, isNotNull);
+    expect(statement.elseKeyword, isNotNull);
+    expect(statement.elseStatement, isNotNull);
+  }
+
+  void test_parseIfStatement_else_statement() {
+    var statement = parseStatement('if (x) f(x); else f(y);') as IfStatement;
+    assertNoErrors();
+    expect(statement.ifKeyword, isNotNull);
+    expect(statement.leftParenthesis, isNotNull);
+    expect(statement.condition, isNotNull);
+    expect(statement.rightParenthesis, isNotNull);
+    expect(statement.thenStatement, isNotNull);
+    expect(statement.elseKeyword, isNotNull);
+    expect(statement.elseStatement, isNotNull);
+  }
+
+  void test_parseIfStatement_noElse_block() {
+    var statement = parseStatement('if (x) {}') as IfStatement;
+    assertNoErrors();
+    expect(statement.ifKeyword, isNotNull);
+    expect(statement.leftParenthesis, isNotNull);
+    expect(statement.condition, isNotNull);
+    expect(statement.rightParenthesis, isNotNull);
+    expect(statement.thenStatement, isNotNull);
+    expect(statement.elseKeyword, isNull);
+    expect(statement.elseStatement, isNull);
+  }
+
+  void test_parseIfStatement_noElse_statement() {
+    var statement = parseStatement('if (x) f(x);') as IfStatement;
+    assertNoErrors();
+    expect(statement.ifKeyword, isNotNull);
+    expect(statement.leftParenthesis, isNotNull);
+    expect(statement.condition, isNotNull);
+    expect(statement.rightParenthesis, isNotNull);
+    expect(statement.thenStatement, isNotNull);
+    expect(statement.elseKeyword, isNull);
+    expect(statement.elseStatement, isNull);
+  }
+
+  void test_parseLocalVariable_external() {
+    parseStatement('external int i;', featureSet: nonNullable);
+    assertErrors(errors: [
+      expectedError(ParserErrorCode.EXTRANEOUS_MODIFIER, 0, 8),
+    ]);
+  }
+
+  void test_parseNonLabeledStatement_const_list_empty() {
+    var statement = parseStatement('const [];') as ExpressionStatement;
+    assertNoErrors();
+    expect(statement.expression, isNotNull);
+  }
+
+  void test_parseNonLabeledStatement_const_list_nonEmpty() {
+    var statement = parseStatement('const [1, 2];') as ExpressionStatement;
+    assertNoErrors();
+    expect(statement.expression, isNotNull);
+  }
+
+  void test_parseNonLabeledStatement_const_map_empty() {
+    var statement = parseStatement('const {};') as ExpressionStatement;
+    assertNoErrors();
+    expect(statement.expression, isNotNull);
+  }
+
+  void test_parseNonLabeledStatement_const_map_nonEmpty() {
+    // TODO(brianwilkerson) Implement more tests for this method.
+    var statement = parseStatement("const {'a' : 1};") as ExpressionStatement;
+    assertNoErrors();
+    expect(statement.expression, isNotNull);
+  }
+
+  void test_parseNonLabeledStatement_const_object() {
+    var statement = parseStatement('const A();') as ExpressionStatement;
+    assertNoErrors();
+    expect(statement.expression, isNotNull);
+  }
+
+  void test_parseNonLabeledStatement_const_object_named_typeParameters() {
+    var statement = parseStatement('const A<B>.c();') as ExpressionStatement;
+    assertNoErrors();
+    expect(statement.expression, isNotNull);
+  }
+
+  void test_parseNonLabeledStatement_const_object_named_typeParameters_34403() {
+    var statement = parseStatement('const A<B>.c<C>();') as ExpressionStatement;
+    assertErrorsWithCodes(
+        [CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS_CONSTRUCTOR]);
+    expect(statement.expression, isNotNull);
+  }
+
+  void test_parseNonLabeledStatement_constructorInvocation() {
+    var statement = parseStatement('new C().m();') as ExpressionStatement;
+    assertNoErrors();
+    expect(statement.expression, isNotNull);
+  }
+
+  void test_parseNonLabeledStatement_false() {
+    var statement = parseStatement('false;') as ExpressionStatement;
+    assertNoErrors();
+    expect(statement.expression, isNotNull);
+  }
+
+  void test_parseNonLabeledStatement_functionDeclaration() {
+    var statement = parseStatement('f() {}') as FunctionDeclarationStatement;
+    assertNoErrors();
+    var function = statement.functionDeclaration.functionExpression;
+    expect(function.parameters.parameters, isEmpty);
+    expect(function.body, isNotNull);
+  }
+
+  void test_parseNonLabeledStatement_functionDeclaration_arguments() {
+    var statement =
+        parseStatement('f(void g()) {}') as FunctionDeclarationStatement;
+    assertNoErrors();
+    var function = statement.functionDeclaration.functionExpression;
+    expect(function.parameters.parameters, hasLength(1));
+    expect(function.body, isNotNull);
+  }
+
+  void test_parseNonLabeledStatement_functionExpressionIndex() {
+    var statement = parseStatement('() {}[0] = null;') as ExpressionStatement;
+    assertNoErrors();
+    expect(statement, isNotNull);
+  }
+
+  void test_parseNonLabeledStatement_functionInvocation() {
+    var statement = parseStatement('f();') as ExpressionStatement;
+    assertNoErrors();
+    expect(statement.expression, isNotNull);
+  }
+
+  void test_parseNonLabeledStatement_invokeFunctionExpression() {
+    var statement =
+        parseStatement('(a) {return a + a;} (3);') as ExpressionStatement;
+    assertNoErrors();
+    var invocation = statement.expression as FunctionExpressionInvocation;
+
+    FunctionExpression expression = invocation.function as FunctionExpression;
+    expect(expression.parameters, isNotNull);
+    expect(expression.body, isNotNull);
+    expect(invocation.typeArguments, isNull);
+    expect(invocation.argumentList.arguments, hasLength(1));
+  }
+
+  void test_parseNonLabeledStatement_localFunction_gftReturnType() {
+    var statement = parseStatement('int Function(int) f(String s) => null;')
+        as FunctionDeclarationStatement;
+    assertNoErrors();
+    FunctionDeclaration function = statement.functionDeclaration;
+    expect(function.returnType, isGenericFunctionType);
+  }
+
+  void test_parseNonLabeledStatement_null() {
+    var statement = parseStatement('null;') as ExpressionStatement;
+    assertNoErrors();
+    expect(statement.expression, isNotNull);
+  }
+
+  void test_parseNonLabeledStatement_startingWithBuiltInIdentifier() {
+    var statement = parseStatement('library.getName();') as ExpressionStatement;
+    assertNoErrors();
+    expect(statement.expression, isNotNull);
+  }
+
+  void test_parseNonLabeledStatement_true() {
+    var statement = parseStatement('true;') as ExpressionStatement;
+    assertNoErrors();
+    expect(statement.expression, isNotNull);
+  }
+
+  void test_parseNonLabeledStatement_typeCast() {
+    var statement = parseStatement('double.NAN as num;') as ExpressionStatement;
+    assertNoErrors();
+    expect(statement.expression, isNotNull);
+  }
+
+  void test_parseNonLabeledStatement_variableDeclaration_final_namedFunction() {
+    var statement = parseStatement('final int Function = 0;')
+        as VariableDeclarationStatement;
+    assertNoErrors();
+    List<VariableDeclaration> variables = statement.variables.variables;
+    expect(variables, hasLength(1));
+    expect(variables[0].name.name, 'Function');
+  }
+
+  void test_parseNonLabeledStatement_variableDeclaration_gftType() {
+    var statement =
+        parseStatement('int Function(int) v;') as VariableDeclarationStatement;
+    assertNoErrors();
+    VariableDeclarationList variableList = statement.variables;
+    List<VariableDeclaration> variables = variableList.variables;
+    expect(variables, hasLength(1));
+    expect(variables[0].name.name, 'v');
+    expect(variableList.type, isGenericFunctionType);
+  }
+
+  void
+      test_parseNonLabeledStatement_variableDeclaration_gftType_functionReturnType() {
+    var statement = parseStatement(
+            'Function Function(int x1, {Function x}) Function<B extends core.int>(int x) v;')
+        as VariableDeclarationStatement;
+    assertNoErrors();
+    VariableDeclarationList variableList = statement.variables;
+    List<VariableDeclaration> variables = variableList.variables;
+    expect(variables, hasLength(1));
+    expect(variables[0].name.name, 'v');
+    expect(variableList.type, isGenericFunctionType);
+  }
+
+  void
+      test_parseNonLabeledStatement_variableDeclaration_gftType_gftReturnType() {
+    var statement = parseStatement('Function(int) Function(int) v;')
+        as VariableDeclarationStatement;
+    assertNoErrors();
+    VariableDeclarationList variableList = statement.variables;
+    List<VariableDeclaration> variables = variableList.variables;
+    expect(variables, hasLength(1));
+    expect(variables[0].name.name, 'v');
+    expect(variableList.type, isGenericFunctionType);
+  }
+
+  void
+      test_parseNonLabeledStatement_variableDeclaration_gftType_gftReturnType2() {
+    var statement = parseStatement('int Function(int) Function(int) v;')
+        as VariableDeclarationStatement;
+    assertNoErrors();
+    VariableDeclarationList variableList = statement.variables;
+    List<VariableDeclaration> variables = variableList.variables;
+    expect(variables, hasLength(1));
+    expect(variables[0].name.name, 'v');
+    expect(variableList.type, isGenericFunctionType);
+  }
+
+  void
+      test_parseNonLabeledStatement_variableDeclaration_gftType_noReturnType() {
+    var statement =
+        parseStatement('Function(int) v;') as VariableDeclarationStatement;
+    assertNoErrors();
+    VariableDeclarationList variableList = statement.variables;
+    List<VariableDeclaration> variables = variableList.variables;
+    expect(variables, hasLength(1));
+    expect(variables[0].name.name, 'v');
+    expect(variableList.type, isGenericFunctionType);
+  }
+
+  void test_parseNonLabeledStatement_variableDeclaration_gftType_returnType() {
+    var statement =
+        parseStatement('int Function<T>() v;') as VariableDeclarationStatement;
+    assertNoErrors();
+    VariableDeclarationList variableList = statement.variables;
+    List<VariableDeclaration> variables = variableList.variables;
+    expect(variables, hasLength(1));
+    expect(variables[0].name.name, 'v');
+    expect(variableList.type, isGenericFunctionType);
+  }
+
+  void
+      test_parseNonLabeledStatement_variableDeclaration_gftType_voidReturnType() {
+    var statement =
+        parseStatement('void Function() v;') as VariableDeclarationStatement;
+    assertNoErrors();
+    VariableDeclarationList variableList = statement.variables;
+    List<VariableDeclaration> variables = variableList.variables;
+    expect(variables, hasLength(1));
+    expect(variables[0].name.name, 'v');
+    expect(variableList.type, isGenericFunctionType);
+  }
+
+  void test_parseNonLabeledStatement_variableDeclaration_typeParam() {
+    VariableDeclarationStatement statement = parseStatement('C<T> v;');
+    assertNoErrors();
+    VariableDeclarationList variableList = statement.variables;
+    List<VariableDeclaration> variables = variableList.variables;
+    expect(variables, hasLength(1));
+    expect(variables[0].name.name, 'v');
+    TypeName typeName = variableList.type;
+    expect(typeName.name.name, 'C');
+    expect(typeName.typeArguments.arguments, hasLength(1));
+    TypeName typeArgument = typeName.typeArguments.arguments[0];
+    expect(typeArgument.name.name, 'T');
+  }
+
+  void test_parseNonLabeledStatement_variableDeclaration_typeParam2() {
+    VariableDeclarationStatement statement =
+        parseStatement('C<T /* ignored comment */ > v;');
+    assertNoErrors();
+    VariableDeclarationList variableList = statement.variables;
+    List<VariableDeclaration> variables = variableList.variables;
+    expect(variables, hasLength(1));
+    expect(variables[0].name.name, 'v');
+    TypeName typeName = variableList.type;
+    expect(typeName.name.name, 'C');
+    expect(typeName.typeArguments.arguments, hasLength(1));
+    TypeName typeArgument = typeName.typeArguments.arguments[0];
+    expect(typeArgument.name.name, 'T');
+  }
+
+  void test_parseNonLabeledStatement_variableDeclaration_typeParam3() {
+    VariableDeclarationStatement statement =
+        parseStatement('C<T Function(String s)> v;');
+    assertNoErrors();
+    VariableDeclarationList variableList = statement.variables;
+    List<VariableDeclaration> variables = variableList.variables;
+    expect(variables, hasLength(1));
+    expect(variables[0].name.name, 'v');
+    TypeName typeName = variableList.type;
+    expect(typeName.name.name, 'C');
+    expect(typeName.typeArguments.arguments, hasLength(1));
+    expect(typeName.typeArguments.arguments[0], isGenericFunctionType);
+  }
+
+  void test_parseStatement_emptyTypeArgumentList() {
+    var declaration = parseStatement('C<> c;') as VariableDeclarationStatement;
+    assertErrorsWithCodes([ParserErrorCode.EXPECTED_TYPE_NAME]);
+    VariableDeclarationList variables = declaration.variables;
+    TypeName type = variables.type;
+    TypeArgumentList argumentList = type.typeArguments;
+    expect(argumentList.leftBracket, isNotNull);
+    expect(argumentList.arguments, hasLength(1));
+    expect(argumentList.arguments[0].isSynthetic, isTrue);
+    expect(argumentList.rightBracket, isNotNull);
+  }
+
+  void test_parseStatement_function_gftReturnType() {
+    var statement =
+        parseStatement('void Function<A>(core.List<core.int> x) m() => null;')
+            as FunctionDeclarationStatement;
+    expect(statement.functionDeclaration.functionExpression.body,
+        isExpressionFunctionBody);
+  }
+
+  void test_parseStatement_functionDeclaration_noReturnType() {
+    var statement = parseStatement('true;') as ExpressionStatement;
+    assertNoErrors();
+    expect(statement.expression, isNotNull);
+  }
+
+  void test_parseStatement_functionDeclaration_noReturnType_typeParameters() {
+    var statement =
+        parseStatement('f<E>(a, b) {}') as FunctionDeclarationStatement;
+    assertNoErrors();
+    expect(statement.functionDeclaration, isNotNull);
+  }
+
+  void test_parseStatement_functionDeclaration_returnType() {
+    // TODO(brianwilkerson) Implement more tests for this method.
+    var statement =
+        parseStatement('int f(a, b) {}') as FunctionDeclarationStatement;
+    assertNoErrors();
+    expect(statement.functionDeclaration, isNotNull);
+  }
+
+  void test_parseStatement_functionDeclaration_returnType_typeParameters() {
+    var statement =
+        parseStatement('int f<E>(a, b) {}') as FunctionDeclarationStatement;
+    assertNoErrors();
+    expect(statement.functionDeclaration, isNotNull);
+  }
+
+  void test_parseStatement_multipleLabels() {
+    var statement = parseStatement('l: m: return x;') as LabeledStatement;
+    expect(statement.labels, hasLength(2));
+    expect(statement.statement, isNotNull);
+  }
+
+  void test_parseStatement_noLabels() {
+    var statement = parseStatement('return x;') as ReturnStatement;
+    assertNoErrors();
+    expect(statement, isNotNull);
+  }
+
+  void test_parseStatement_singleLabel() {
+    var statement = parseStatement('l: return x;') as LabeledStatement;
+    assertNoErrors();
+    expect(statement.labels, hasLength(1));
+    expect(statement.labels[0].label.inDeclarationContext(), isTrue);
+    expect(statement.statement, isNotNull);
+  }
+
+  void test_parseSwitchStatement_case() {
+    var statement =
+        parseStatement('switch (a) {case 1: return "I";}') as SwitchStatement;
+    assertNoErrors();
+    expect(statement.switchKeyword, isNotNull);
+    expect(statement.leftParenthesis, isNotNull);
+    expect(statement.expression, isNotNull);
+    expect(statement.rightParenthesis, isNotNull);
+    expect(statement.leftBracket, isNotNull);
+    expect(statement.members, hasLength(1));
+    expect(statement.rightBracket, isNotNull);
+  }
+
+  void test_parseSwitchStatement_empty() {
+    var statement = parseStatement('switch (a) {}') as SwitchStatement;
+    assertNoErrors();
+    expect(statement.switchKeyword, isNotNull);
+    expect(statement.leftParenthesis, isNotNull);
+    expect(statement.expression, isNotNull);
+    expect(statement.rightParenthesis, isNotNull);
+    expect(statement.leftBracket, isNotNull);
+    expect(statement.members, hasLength(0));
+    expect(statement.rightBracket, isNotNull);
+  }
+
+  void test_parseSwitchStatement_labeledCase() {
+    var statement =
+        parseStatement('switch (a) {l1: l2: l3: case(1):}') as SwitchStatement;
+    assertNoErrors();
+    expect(statement.switchKeyword, isNotNull);
+    expect(statement.leftParenthesis, isNotNull);
+    expect(statement.expression, isNotNull);
+    expect(statement.rightParenthesis, isNotNull);
+    expect(statement.leftBracket, isNotNull);
+    expect(statement.members, hasLength(1));
+    {
+      List<Label> labels = statement.members[0].labels;
+      expect(labels, hasLength(3));
+      expect(labels[0].label.inDeclarationContext(), isTrue);
+      expect(labels[1].label.inDeclarationContext(), isTrue);
+      expect(labels[2].label.inDeclarationContext(), isTrue);
+    }
+    expect(statement.rightBracket, isNotNull);
+  }
+
+  void test_parseSwitchStatement_labeledCase2() {
+    SwitchStatement statement =
+        parseStatement('switch (a) {l1: case 0: l2: case 1: return;}');
+    assertNoErrors();
+    expect(statement.switchKeyword, isNotNull);
+    expect(statement.leftParenthesis, isNotNull);
+    expect(statement.expression, isNotNull);
+    expect(statement.rightParenthesis, isNotNull);
+    expect(statement.leftBracket, isNotNull);
+    expect(statement.members, hasLength(2));
+    {
+      List<Label> labels = statement.members[0].labels;
+      expect(labels, hasLength(1));
+      expect(labels[0].label.inDeclarationContext(), isTrue);
+    }
+    {
+      List<Label> labels = statement.members[1].labels;
+      expect(labels, hasLength(1));
+      expect(labels[0].label.inDeclarationContext(), isTrue);
+    }
+    expect(statement.rightBracket, isNotNull);
+  }
+
+  void test_parseSwitchStatement_labeledDefault() {
+    var statement =
+        parseStatement('switch (a) {l1: l2: l3: default:}') as SwitchStatement;
+    assertNoErrors();
+    expect(statement.switchKeyword, isNotNull);
+    expect(statement.leftParenthesis, isNotNull);
+    expect(statement.expression, isNotNull);
+    expect(statement.rightParenthesis, isNotNull);
+    expect(statement.leftBracket, isNotNull);
+    expect(statement.members, hasLength(1));
+    {
+      List<Label> labels = statement.members[0].labels;
+      expect(labels, hasLength(3));
+      expect(labels[0].label.inDeclarationContext(), isTrue);
+      expect(labels[1].label.inDeclarationContext(), isTrue);
+      expect(labels[2].label.inDeclarationContext(), isTrue);
+    }
+    expect(statement.rightBracket, isNotNull);
+  }
+
+  void test_parseSwitchStatement_labeledDefault2() {
+    SwitchStatement statement =
+        parseStatement('switch (a) {l1: case 0: l2: default: return;}');
+    assertNoErrors();
+    expect(statement.switchKeyword, isNotNull);
+    expect(statement.leftParenthesis, isNotNull);
+    expect(statement.expression, isNotNull);
+    expect(statement.rightParenthesis, isNotNull);
+    expect(statement.leftBracket, isNotNull);
+    expect(statement.members, hasLength(2));
+    {
+      List<Label> labels = statement.members[0].labels;
+      expect(labels, hasLength(1));
+      expect(labels[0].label.inDeclarationContext(), isTrue);
+    }
+    {
+      List<Label> labels = statement.members[1].labels;
+      expect(labels, hasLength(1));
+      expect(labels[0].label.inDeclarationContext(), isTrue);
+    }
+    expect(statement.rightBracket, isNotNull);
+  }
+
+  void test_parseSwitchStatement_labeledStatementInCase() {
+    var statement = parseStatement('switch (a) {case 0: f(); l1: g(); break;}')
+        as SwitchStatement;
+    assertNoErrors();
+    expect(statement.switchKeyword, isNotNull);
+    expect(statement.leftParenthesis, isNotNull);
+    expect(statement.expression, isNotNull);
+    expect(statement.rightParenthesis, isNotNull);
+    expect(statement.leftBracket, isNotNull);
+    expect(statement.members, hasLength(1));
+    expect(statement.members[0].statements, hasLength(3));
+    expect(statement.rightBracket, isNotNull);
+  }
+
+  void test_parseTryStatement_catch() {
+    var statement = parseStatement('try {} catch (e) {}') as TryStatement;
+    assertNoErrors();
+    expect(statement.tryKeyword, isNotNull);
+    expect(statement.body, isNotNull);
+    NodeList<CatchClause> catchClauses = statement.catchClauses;
+    expect(catchClauses, hasLength(1));
+    CatchClause clause = catchClauses[0];
+    expect(clause.onKeyword, isNull);
+    expect(clause.exceptionType, isNull);
+    expect(clause.catchKeyword, isNotNull);
+    expect(clause.exceptionParameter, isNotNull);
+    expect(clause.comma, isNull);
+    expect(clause.stackTraceParameter, isNull);
+    expect(clause.body, isNotNull);
+    expect(statement.finallyKeyword, isNull);
+    expect(statement.finallyBlock, isNull);
+  }
+
+  void test_parseTryStatement_catch_error_invalidCatchParam() {
+    CompilationUnit unit = parseCompilationUnit(
+        'main() { try {} catch (int e) { } }',
+        errors: [expectedError(ParserErrorCode.CATCH_SYNTAX, 27, 1)]);
+    FunctionDeclaration method = unit.declarations[0];
+    BlockFunctionBody body = method.functionExpression.body;
+    TryStatement statement = body.block.statements[0];
+    expect(statement.tryKeyword, isNotNull);
+    expect(statement.body, isNotNull);
+    NodeList<CatchClause> catchClauses = statement.catchClauses;
+    expect(catchClauses, hasLength(1));
+    CatchClause clause = catchClauses[0];
+    expect(clause.onKeyword, isNull);
+    expect(clause.exceptionType, isNull);
+    expect(clause.catchKeyword, isNotNull);
+    expect(clause.exceptionParameter.name, 'int');
+    expect(clause.comma, isNotNull);
+    expect(clause.stackTraceParameter.name, 'e');
+    expect(clause.body, isNotNull);
+    expect(statement.finallyKeyword, isNull);
+    expect(statement.finallyBlock, isNull);
+  }
+
+  void test_parseTryStatement_catch_error_missingCatchParam() {
+    var statement = parseStatement('try {} catch () {}') as TryStatement;
+    listener.assertErrors([expectedError(ParserErrorCode.CATCH_SYNTAX, 14, 1)]);
+    expect(statement.tryKeyword, isNotNull);
+    expect(statement.body, isNotNull);
+    NodeList<CatchClause> catchClauses = statement.catchClauses;
+    expect(catchClauses, hasLength(1));
+    CatchClause clause = catchClauses[0];
+    expect(clause.onKeyword, isNull);
+    expect(clause.exceptionType, isNull);
+    expect(clause.catchKeyword, isNotNull);
+    expect(clause.exceptionParameter, isNotNull);
+    expect(clause.comma, isNull);
+    expect(clause.stackTraceParameter, isNull);
+    expect(clause.body, isNotNull);
+    expect(statement.finallyKeyword, isNull);
+    expect(statement.finallyBlock, isNull);
+  }
+
+  void test_parseTryStatement_catch_error_missingCatchParen() {
+    var statement = parseStatement('try {} catch {}') as TryStatement;
+    listener.assertErrors([expectedError(ParserErrorCode.CATCH_SYNTAX, 13, 1)]);
+    expect(statement.tryKeyword, isNotNull);
+    expect(statement.body, isNotNull);
+    NodeList<CatchClause> catchClauses = statement.catchClauses;
+    expect(catchClauses, hasLength(1));
+    CatchClause clause = catchClauses[0];
+    expect(clause.onKeyword, isNull);
+    expect(clause.exceptionType, isNull);
+    expect(clause.catchKeyword, isNotNull);
+    expect(clause.exceptionParameter, isNotNull);
+    expect(clause.comma, isNull);
+    expect(clause.stackTraceParameter, isNull);
+    expect(clause.body, isNotNull);
+    expect(statement.finallyKeyword, isNull);
+    expect(statement.finallyBlock, isNull);
+  }
+
+  void test_parseTryStatement_catch_error_missingCatchTrace() {
+    var statement = parseStatement('try {} catch (e,) {}') as TryStatement;
+    listener.assertErrors([expectedError(ParserErrorCode.CATCH_SYNTAX, 16, 1)]);
+    expect(statement.tryKeyword, isNotNull);
+    expect(statement.body, isNotNull);
+    NodeList<CatchClause> catchClauses = statement.catchClauses;
+    expect(catchClauses, hasLength(1));
+    CatchClause clause = catchClauses[0];
+    expect(clause.onKeyword, isNull);
+    expect(clause.exceptionType, isNull);
+    expect(clause.catchKeyword, isNotNull);
+    expect(clause.exceptionParameter, isNotNull);
+    expect(clause.comma, isNotNull);
+    expect(clause.stackTraceParameter, isNotNull);
+    expect(clause.body, isNotNull);
+    expect(statement.finallyKeyword, isNull);
+    expect(statement.finallyBlock, isNull);
+  }
+
+  void test_parseTryStatement_catch_finally() {
+    var statement =
+        parseStatement('try {} catch (e, s) {} finally {}') as TryStatement;
+    assertNoErrors();
+    expect(statement.tryKeyword, isNotNull);
+    expect(statement.body, isNotNull);
+    NodeList<CatchClause> catchClauses = statement.catchClauses;
+    expect(catchClauses, hasLength(1));
+    CatchClause clause = catchClauses[0];
+    expect(clause.onKeyword, isNull);
+    expect(clause.exceptionType, isNull);
+    expect(clause.catchKeyword, isNotNull);
+    expect(clause.exceptionParameter, isNotNull);
+    expect(clause.comma, isNotNull);
+    expect(clause.stackTraceParameter, isNotNull);
+    expect(clause.body, isNotNull);
+    expect(statement.finallyKeyword, isNotNull);
+    expect(statement.finallyBlock, isNotNull);
+  }
+
+  void test_parseTryStatement_finally() {
+    var statement = parseStatement('try {} finally {}') as TryStatement;
+    assertNoErrors();
+    expect(statement.tryKeyword, isNotNull);
+    expect(statement.body, isNotNull);
+    expect(statement.catchClauses, hasLength(0));
+    expect(statement.finallyKeyword, isNotNull);
+    expect(statement.finallyBlock, isNotNull);
+  }
+
+  void test_parseTryStatement_multiple() {
+    var statement =
+        parseStatement('try {} on NPE catch (e) {} on Error {} catch (e) {}')
+            as TryStatement;
+    assertNoErrors();
+    expect(statement.tryKeyword, isNotNull);
+    expect(statement.body, isNotNull);
+    expect(statement.catchClauses, hasLength(3));
+    expect(statement.finallyKeyword, isNull);
+    expect(statement.finallyBlock, isNull);
+  }
+
+  void test_parseTryStatement_on() {
+    var statement = parseStatement('try {} on Error {}') as TryStatement;
+    assertNoErrors();
+    expect(statement.tryKeyword, isNotNull);
+    expect(statement.body, isNotNull);
+    NodeList<CatchClause> catchClauses = statement.catchClauses;
+    expect(catchClauses, hasLength(1));
+    CatchClause clause = catchClauses[0];
+    expect(clause.onKeyword, isNotNull);
+    expect(clause.exceptionType, isNotNull);
+    expect(clause.catchKeyword, isNull);
+    expect(clause.exceptionParameter, isNull);
+    expect(clause.comma, isNull);
+    expect(clause.stackTraceParameter, isNull);
+    expect(clause.body, isNotNull);
+    expect(statement.finallyKeyword, isNull);
+    expect(statement.finallyBlock, isNull);
+  }
+
+  void test_parseTryStatement_on_catch() {
+    var statement =
+        parseStatement('try {} on Error catch (e, s) {}') as TryStatement;
+    assertNoErrors();
+    expect(statement.tryKeyword, isNotNull);
+    expect(statement.body, isNotNull);
+    NodeList<CatchClause> catchClauses = statement.catchClauses;
+    expect(catchClauses, hasLength(1));
+    CatchClause clause = catchClauses[0];
+    expect(clause.onKeyword, isNotNull);
+    expect(clause.exceptionType, isNotNull);
+    expect(clause.catchKeyword, isNotNull);
+    expect(clause.exceptionParameter, isNotNull);
+    expect(clause.comma, isNotNull);
+    expect(clause.stackTraceParameter, isNotNull);
+    expect(clause.body, isNotNull);
+    expect(statement.finallyKeyword, isNull);
+    expect(statement.finallyBlock, isNull);
+  }
+
+  void test_parseTryStatement_on_catch_finally() {
+    var statement = parseStatement('try {} on Error catch (e, s) {} finally {}')
+        as TryStatement;
+    assertNoErrors();
+    expect(statement.tryKeyword, isNotNull);
+    expect(statement.body, isNotNull);
+    NodeList<CatchClause> catchClauses = statement.catchClauses;
+    expect(catchClauses, hasLength(1));
+    CatchClause clause = catchClauses[0];
+    expect(clause.onKeyword, isNotNull);
+    expect(clause.exceptionType, isNotNull);
+    expect(clause.catchKeyword, isNotNull);
+    expect(clause.exceptionParameter, isNotNull);
+    expect(clause.comma, isNotNull);
+    expect(clause.stackTraceParameter, isNotNull);
+    expect(clause.body, isNotNull);
+    expect(statement.finallyKeyword, isNotNull);
+    expect(statement.finallyBlock, isNotNull);
+  }
+
+  void test_parseVariableDeclaration_equals_builtIn() {
+    VariableDeclarationStatement statement = parseStatement('int set = 0;');
+    assertNoErrors();
+    expect(statement.semicolon, isNotNull);
+    VariableDeclarationList variableList = statement.variables;
+    expect(variableList, isNotNull);
+    expect(variableList.variables, hasLength(1));
+  }
+
+  void test_parseVariableDeclarationListAfterMetadata_const_noType() {
+    var declarationList = parseVariableDeclarationList('const a = 0');
+    assertNoErrors();
+    expect(declarationList.keyword.lexeme, 'const');
+    expect(declarationList.type, isNull);
+    expect(declarationList.variables, hasLength(1));
+  }
+
+  void test_parseVariableDeclarationListAfterMetadata_const_type() {
+    var declarationList = parseVariableDeclarationList('const A a');
+    assertNoErrors();
+    expect(declarationList.keyword.lexeme, 'const');
+    expect(declarationList.type, isNotNull);
+    expect(declarationList.variables, hasLength(1));
+  }
+
+  void test_parseVariableDeclarationListAfterMetadata_final_noType() {
+    var declarationList = parseVariableDeclarationList('final a');
+    assertNoErrors();
+    expect(declarationList.keyword, isNotNull);
+    expect(declarationList.type, isNull);
+    expect(declarationList.variables, hasLength(1));
+  }
+
+  void test_parseVariableDeclarationListAfterMetadata_final_type() {
+    var declarationList = parseVariableDeclarationList('final A a');
+    assertNoErrors();
+    expect(declarationList.keyword.lexeme, 'final');
+    expect(declarationList.type, isNotNull);
+    expect(declarationList.variables, hasLength(1));
+  }
+
+  void test_parseVariableDeclarationListAfterMetadata_type_multiple() {
+    var declarationList = parseVariableDeclarationList('A a, b, c');
+    assertNoErrors();
+    expect(declarationList.keyword, isNull);
+    expect(declarationList.type, isNotNull);
+    expect(declarationList.variables, hasLength(3));
+  }
+
+  void test_parseVariableDeclarationListAfterMetadata_type_single() {
+    var declarationList = parseVariableDeclarationList('A a');
+    assertNoErrors();
+    expect(declarationList.keyword, isNull);
+    expect(declarationList.type, isNotNull);
+    expect(declarationList.variables, hasLength(1));
+  }
+
+  void test_parseVariableDeclarationListAfterMetadata_var_multiple() {
+    var declarationList = parseVariableDeclarationList('var a, b, c');
+    assertNoErrors();
+    expect(declarationList.keyword.lexeme, 'var');
+    expect(declarationList.type, isNull);
+    expect(declarationList.variables, hasLength(3));
+  }
+
+  void test_parseVariableDeclarationListAfterMetadata_var_single() {
+    var declarationList = parseVariableDeclarationList('var a');
+    assertNoErrors();
+    expect(declarationList.keyword.lexeme, 'var');
+    expect(declarationList.type, isNull);
+    expect(declarationList.variables, hasLength(1));
+  }
+
+  void test_parseVariableDeclarationStatementAfterMetadata_multiple() {
+    var statement =
+        parseStatement('var x, y, z;') as VariableDeclarationStatement;
+    assertNoErrors();
+    expect(statement.semicolon, isNotNull);
+    VariableDeclarationList variableList = statement.variables;
+    expect(variableList, isNotNull);
+    expect(variableList.variables, hasLength(3));
+  }
+
+  void test_parseVariableDeclarationStatementAfterMetadata_single() {
+    var statement = parseStatement('var x;') as VariableDeclarationStatement;
+    assertNoErrors();
+    expect(statement.semicolon, isNotNull);
+    VariableDeclarationList variableList = statement.variables;
+    expect(variableList, isNotNull);
+    expect(variableList.variables, hasLength(1));
+  }
+
+  void test_parseWhileStatement() {
+    var statement = parseStatement('while (x) {}') as WhileStatement;
+    assertNoErrors();
+    expect(statement.whileKeyword, isNotNull);
+    expect(statement.leftParenthesis, isNotNull);
+    expect(statement.condition, isNotNull);
+    expect(statement.rightParenthesis, isNotNull);
+    expect(statement.body, isNotNull);
+  }
+
+  void test_parseYieldStatement_each() {
+    var statement =
+        _parseAsyncStatement('yield* x;', isGenerator: true) as YieldStatement;
+    assertNoErrors();
+    expect(statement.yieldKeyword, isNotNull);
+    expect(statement.star, isNotNull);
+    expect(statement.expression, isNotNull);
+    expect(statement.semicolon, isNotNull);
+  }
+
+  void test_parseYieldStatement_normal() {
+    var statement =
+        _parseAsyncStatement('yield x;', isGenerator: true) as YieldStatement;
+    assertNoErrors();
+    expect(statement.yieldKeyword, isNotNull);
+    expect(statement.star, isNull);
+    expect(statement.expression, isNotNull);
+    expect(statement.semicolon, isNotNull);
+  }
+
+  void test_partial_typeArg1_34850() {
+    var unit = parseCompilationUnit('<bar<', errors: [
+      expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 0, 1),
+      expectedError(ParserErrorCode.MISSING_IDENTIFIER, 5, 0),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 1, 3),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 5, 0),
+    ]);
+    // Validate that recovery has properly updated the token stream.
+    analyzer.Token token = unit.beginToken;
+    while (!token.isEof) {
+      expect(token.type, isNot(TokenType.GT_GT));
+      analyzer.Token next = token.next;
+      expect(next.previous, token);
+      token = next;
+    }
+  }
+
+  void test_partial_typeArg2_34850() {
+    var unit = parseCompilationUnit('foo <bar<', errors: [
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 5, 3),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_PARAMETERS, 0, 3),
+      expectedError(ParserErrorCode.MISSING_FUNCTION_BODY, 9, 0),
+    ]);
+    // Validate that recovery has properly updated the token stream.
+    analyzer.Token token = unit.beginToken;
+    while (!token.isEof) {
+      expect(token.type, isNot(TokenType.GT_GT));
+      analyzer.Token next = token.next;
+      expect(next.previous, token);
+      token = next;
+    }
+  }
+
+  Statement _parseAsyncStatement(String code, {bool isGenerator = false}) {
+    var star = isGenerator ? '*' : '';
+    var localFunction = parseStatement('wrapper() async$star { $code }')
+        as FunctionDeclarationStatement;
+    var localBody = localFunction.functionDeclaration.functionExpression.body
+        as BlockFunctionBody;
+    return localBody.block.statements.single;
+  }
+}
diff --git a/pkg/analyzer/test/generated/strong_mode_test.dart b/pkg/analyzer/test/generated/strong_mode_test.dart
index c291ea0..ca63fe8 100644
--- a/pkg/analyzer/test/generated/strong_mode_test.dart
+++ b/pkg/analyzer/test/generated/strong_mode_test.dart
@@ -1702,7 +1702,8 @@
 
     {
       List<Statement> statements =
-          AstFinder.getStatementsInTopLevelFunction(unit, "test2").cast<VariableDeclarationStatement>();
+          AstFinder.getStatementsInTopLevelFunction(unit, "test2")
+              .cast<VariableDeclarationStatement>();
       hasType(assertBOf([_isString, _isInt]), rhs(statements[0]));
       hasType(assertBOf([_isString, _isInt]), rhs(statements[1]));
       hasType(assertBOf([_isString, _isInt]), rhs(statements[2]));
@@ -1713,14 +1714,16 @@
 
     {
       List<Statement> statements =
-          AstFinder.getStatementsInTopLevelFunction(unit, "test3").cast<VariableDeclarationStatement>();
+          AstFinder.getStatementsInTopLevelFunction(unit, "test3")
+              .cast<VariableDeclarationStatement>();
       hasType(assertBOf([_isString, _isInt]), rhs(statements[0]));
       hasType(assertBOf([_isString, _isInt]), rhs(statements[1]));
     }
 
     {
       List<Statement> statements =
-          AstFinder.getStatementsInTopLevelFunction(unit, "test4").cast<VariableDeclarationStatement>();
+          AstFinder.getStatementsInTopLevelFunction(unit, "test4")
+              .cast<VariableDeclarationStatement>();
       hasType(assertCOf([_isInt]), rhs(statements[0]));
       hasType(assertCOf([_isInt]), rhs(statements[1]));
       hasType(assertCOf([_isInt]), rhs(statements[2]));
@@ -1731,7 +1734,8 @@
 
     {
       List<Statement> statements =
-          AstFinder.getStatementsInTopLevelFunction(unit, "test5").cast<VariableDeclarationStatement>();
+          AstFinder.getStatementsInTopLevelFunction(unit, "test5")
+              .cast<VariableDeclarationStatement>();
       hasType(assertCOf([_isInt]), rhs(statements[0]));
       hasType(assertCOf([_isInt]), rhs(statements[1]));
     }
@@ -1741,7 +1745,8 @@
       // context.  We could choose a tighter type, but currently
       // we just use dynamic.
       List<Statement> statements =
-          AstFinder.getStatementsInTopLevelFunction(unit, "test6").cast<VariableDeclarationStatement>();
+          AstFinder.getStatementsInTopLevelFunction(unit, "test6")
+              .cast<VariableDeclarationStatement>();
       hasType(assertDOf([_isDynamic, _isString]), rhs(statements[0]));
       hasType(assertDOf([_isDynamic, _isString]), rhs(statements[1]));
       hasType(assertDOf([_isInt, _isString]), rhs(statements[2]));
@@ -1752,20 +1757,23 @@
 
     {
       List<Statement> statements =
-          AstFinder.getStatementsInTopLevelFunction(unit, "test7").cast<VariableDeclarationStatement>();
+          AstFinder.getStatementsInTopLevelFunction(unit, "test7")
+              .cast<VariableDeclarationStatement>();
       hasType(assertDOf([_isDynamic, _isString]), rhs(statements[0]));
       hasType(assertDOf([_isDynamic, _isString]), rhs(statements[1]));
     }
 
     {
       List<Statement> statements =
-          AstFinder.getStatementsInTopLevelFunction(unit, "test8").cast<VariableDeclarationStatement>();
+          AstFinder.getStatementsInTopLevelFunction(unit, "test8")
+              .cast<VariableDeclarationStatement>();
       hasType(assertEOf([_isInt, _isString]), rhs(statements[0]));
     }
 
     {
       List<Statement> statements =
-          AstFinder.getStatementsInTopLevelFunction(unit, "test9").cast<VariableDeclarationStatement>();
+          AstFinder.getStatementsInTopLevelFunction(unit, "test9")
+              .cast<VariableDeclarationStatement>();
       hasType(assertFOf([_isInt, _isString]), rhs(statements[0]));
       hasType(assertFOf([_isInt, _isString]), rhs(statements[1]));
       hasType(assertFOf([_isInt, _isString]), rhs(statements[2]));
@@ -1810,9 +1818,12 @@
     assertListOfListOfInt(literal(2).staticType as InterfaceType);
     assertListOfListOfInt(literal(3).staticType as InterfaceType);
 
-    assertListOfInt((literal(1).elements[0] as Expression).staticType as InterfaceType);
-    assertListOfInt((literal(2).elements[0] as Expression).staticType as InterfaceType);
-    assertListOfInt((literal(3).elements[0] as Expression).staticType as InterfaceType);
+    assertListOfInt(
+        (literal(1).elements[0] as Expression).staticType as InterfaceType);
+    assertListOfInt(
+        (literal(2).elements[0] as Expression).staticType as InterfaceType);
+    assertListOfInt(
+        (literal(3).elements[0] as Expression).staticType as InterfaceType);
   }
 
   test_listLiteral_simple() async {
diff --git a/pkg/analyzer/test/generated/test_all.dart b/pkg/analyzer/test/generated/test_all.dart
index 42ff098..7ef4b60 100644
--- a/pkg/analyzer/test/generated/test_all.dart
+++ b/pkg/analyzer/test/generated/test_all.dart
@@ -5,56 +5,80 @@
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import 'all_the_rest_test.dart' as all_the_rest;
+import 'class_member_parser_test.dart' as class_member_parser;
+import 'collection_literal_parser_test.dart' as collection_literal_parser;
+import 'complex_parser_test.dart' as complex_parser;
 // ignore: deprecated_member_use_from_same_package
 import 'constant_test.dart' as constant_test;
 import 'element_resolver_test.dart' as element_resolver_test;
+import 'error_parser_test.dart' as error_parser;
 import 'error_suppression_test.dart' as error_suppression;
+import 'expression_parser_test.dart' as expression_parser;
+import 'extension_methods_parser_test.dart' as extension_methods_parser;
+import 'formal_parameter_parser_test.dart' as formal_parameter_parser;
 import 'invalid_code_test.dart' as invalid_code;
 import 'issues_test.dart' as issues;
 import 'java_core_test.dart' as java_core_test;
 import 'java_io_test.dart' as java_io_test;
+import 'nnbd_parser_test.dart' as nnbd_parser;
+import 'non_error_parser_test.dart' as non_error_parser;
 import 'non_error_resolver_test.dart' as non_error_resolver;
 import 'non_hint_code_test.dart' as non_hint_code;
-import 'parser_fasta_test.dart' as parser_fasta_test;
-import 'parser_test.dart' as parser_test;
+import 'recovery_parser_test.dart' as recovery_parser;
 import 'resolver_test.dart' as resolver_test;
 import 'scanner_test.dart' as scanner_test;
 import 'sdk_test.dart' as sdk_test;
+import 'simple_parser_test.dart' as simple_parser;
 import 'simple_resolver_test.dart' as simple_resolver_test;
 import 'source_factory_test.dart' as source_factory_test;
+import 'statement_parser_test.dart' as statement_parser;
 import 'static_type_analyzer_test.dart' as static_type_analyzer_test;
 import 'static_type_warning_code_test.dart' as static_type_warning_code;
 import 'static_warning_code_test.dart' as static_warning_code;
 import 'strong_mode_test.dart' as strong_mode;
+import 'top_level_parser_test.dart' as top_level_parser;
 import 'type_system_test.dart' as type_system_test;
 import 'utilities_dart_test.dart' as utilities_dart_test;
 import 'utilities_test.dart' as utilities_test;
+import 'variance_parser_test.dart' as variance_parser;
 
 main() {
   defineReflectiveSuite(() {
     all_the_rest.main();
+    class_member_parser.main();
+    collection_literal_parser.main();
+    complex_parser.main();
     constant_test.main();
     element_resolver_test.main();
+    error_parser.main();
     error_suppression.main();
+    expression_parser.main();
+    extension_methods_parser.main();
+    formal_parameter_parser.main();
     invalid_code.main();
     issues.main();
     java_core_test.main();
     java_io_test.main();
+    nnbd_parser.main();
+    non_error_parser.main();
     non_error_resolver.main();
     non_hint_code.main();
-    parser_fasta_test.main();
-    parser_test.main();
+    recovery_parser.main();
     resolver_test.main();
     scanner_test.main();
     sdk_test.main();
+    simple_parser.main();
     simple_resolver_test.main();
     source_factory_test.main();
+    statement_parser.main();
     static_type_analyzer_test.main();
     static_type_warning_code.main();
     static_warning_code.main();
     strong_mode.main();
+    top_level_parser.main();
     type_system_test.main();
     utilities_dart_test.main();
     utilities_test.main();
+    variance_parser.main();
   }, name: 'generated');
 }
diff --git a/pkg/analyzer/test/generated/top_level_parser_test.dart b/pkg/analyzer/test/generated/top_level_parser_test.dart
new file mode 100644
index 0000000..5e36c1c3
--- /dev/null
+++ b/pkg/analyzer/test/generated/top_level_parser_test.dart
@@ -0,0 +1,2430 @@
+// Copyright (c) 2020, 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.
+
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/error/error.dart';
+import 'package:analyzer/src/dart/scanner/scanner.dart';
+import 'package:analyzer/src/error/codes.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../util/ast_type_matchers.dart';
+import 'parser_test_base.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(TopLevelParserTest);
+  });
+}
+
+/// Tests which exercise the parser using a complete compilation unit or
+/// compilation unit member.
+@reflectiveTest
+class TopLevelParserTest extends FastaParserTestCase {
+  void test_function_literal_allowed_at_toplevel() {
+    parseCompilationUnit("var x = () {};");
+  }
+
+  void
+      test_function_literal_allowed_in_ArgumentList_in_ConstructorFieldInitializer() {
+    parseCompilationUnit("class C { C() : a = f(() {}); }");
+  }
+
+  void
+      test_function_literal_allowed_in_IndexExpression_in_ConstructorFieldInitializer() {
+    parseCompilationUnit("class C { C() : a = x[() {}]; }");
+  }
+
+  void
+      test_function_literal_allowed_in_ListLiteral_in_ConstructorFieldInitializer() {
+    parseCompilationUnit("class C { C() : a = [() {}]; }");
+  }
+
+  void
+      test_function_literal_allowed_in_MapLiteral_in_ConstructorFieldInitializer() {
+    parseCompilationUnit("class C { C() : a = {'key': () {}}; }");
+  }
+
+  void
+      test_function_literal_allowed_in_ParenthesizedExpression_in_ConstructorFieldInitializer() {
+    parseCompilationUnit("class C { C() : a = (() {}); }");
+  }
+
+  void
+      test_function_literal_allowed_in_StringInterpolation_in_ConstructorFieldInitializer() {
+    parseCompilationUnit("class C { C() : a = \"\${(){}}\"; }");
+  }
+
+  void test_import_as_show() {
+    parseCompilationUnit("import 'dart:math' as M show E;");
+  }
+
+  void test_import_show_hide() {
+    parseCompilationUnit(
+        "import 'import1_lib.dart' show hide, show hide ugly;");
+  }
+
+  void test_import_withDocComment() {
+    var compilationUnit = parseCompilationUnit('/// Doc\nimport "foo.dart";');
+    var importDirective = compilationUnit.directives[0];
+    expectCommentText(importDirective.documentationComment, '/// Doc');
+  }
+
+  void test_parseClassDeclaration_abstract() {
+    createParser('abstract class A {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isClassDeclaration);
+    ClassDeclaration declaration = member;
+    expect(declaration.documentationComment, isNull);
+    expect(declaration.abstractKeyword, isNotNull);
+    expect(declaration.extendsClause, isNull);
+    expect(declaration.implementsClause, isNull);
+    expect(declaration.classKeyword, isNotNull);
+    expect(declaration.leftBracket, isNotNull);
+    expect(declaration.name, isNotNull);
+    expect(declaration.members, hasLength(0));
+    expect(declaration.rightBracket, isNotNull);
+    expect(declaration.typeParameters, isNull);
+  }
+
+  void test_parseClassDeclaration_empty() {
+    createParser('class A {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isClassDeclaration);
+    ClassDeclaration declaration = member;
+    expect(declaration.documentationComment, isNull);
+    expect(declaration.abstractKeyword, isNull);
+    expect(declaration.extendsClause, isNull);
+    expect(declaration.implementsClause, isNull);
+    expect(declaration.classKeyword, isNotNull);
+    expect(declaration.leftBracket, isNotNull);
+    expect(declaration.name, isNotNull);
+    _assertIsDeclarationName(declaration.name);
+    expect(declaration.members, hasLength(0));
+    expect(declaration.rightBracket, isNotNull);
+    expect(declaration.typeParameters, isNull);
+  }
+
+  void test_parseClassDeclaration_extends() {
+    createParser('class A extends B {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isClassDeclaration);
+    ClassDeclaration declaration = member;
+    expect(declaration.documentationComment, isNull);
+    expect(declaration.abstractKeyword, isNull);
+    expect(declaration.extendsClause, isNotNull);
+    expect(declaration.implementsClause, isNull);
+    expect(declaration.classKeyword, isNotNull);
+    expect(declaration.leftBracket, isNotNull);
+    expect(declaration.name, isNotNull);
+    expect(declaration.members, hasLength(0));
+    expect(declaration.rightBracket, isNotNull);
+    expect(declaration.typeParameters, isNull);
+  }
+
+  void test_parseClassDeclaration_extendsAndImplements() {
+    createParser('class A extends B implements C {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isClassDeclaration);
+    ClassDeclaration declaration = member;
+    expect(declaration.documentationComment, isNull);
+    expect(declaration.abstractKeyword, isNull);
+    expect(declaration.extendsClause, isNotNull);
+    expect(declaration.implementsClause, isNotNull);
+    expect(declaration.classKeyword, isNotNull);
+    expect(declaration.leftBracket, isNotNull);
+    expect(declaration.name, isNotNull);
+    expect(declaration.members, hasLength(0));
+    expect(declaration.rightBracket, isNotNull);
+    expect(declaration.typeParameters, isNull);
+  }
+
+  void test_parseClassDeclaration_extendsAndWith() {
+    createParser('class A extends B with C {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isClassDeclaration);
+    ClassDeclaration declaration = member;
+    expect(declaration.documentationComment, isNull);
+    expect(declaration.abstractKeyword, isNull);
+    expect(declaration.classKeyword, isNotNull);
+    expect(declaration.name, isNotNull);
+    expect(declaration.typeParameters, isNull);
+    expect(declaration.extendsClause, isNotNull);
+    expect(declaration.withClause, isNotNull);
+    expect(declaration.implementsClause, isNull);
+    expect(declaration.leftBracket, isNotNull);
+    expect(declaration.members, hasLength(0));
+    expect(declaration.rightBracket, isNotNull);
+  }
+
+  void test_parseClassDeclaration_extendsAndWithAndImplements() {
+    createParser('class A extends B with C implements D {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isClassDeclaration);
+    ClassDeclaration declaration = member;
+    expect(declaration.documentationComment, isNull);
+    expect(declaration.abstractKeyword, isNull);
+    expect(declaration.classKeyword, isNotNull);
+    expect(declaration.name, isNotNull);
+    expect(declaration.typeParameters, isNull);
+    expect(declaration.extendsClause, isNotNull);
+    expect(declaration.withClause, isNotNull);
+    expect(declaration.implementsClause, isNotNull);
+    expect(declaration.leftBracket, isNotNull);
+    expect(declaration.members, hasLength(0));
+    expect(declaration.rightBracket, isNotNull);
+  }
+
+  void test_parseClassDeclaration_implements() {
+    createParser('class A implements C {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isClassDeclaration);
+    ClassDeclaration declaration = member;
+    expect(declaration.documentationComment, isNull);
+    expect(declaration.abstractKeyword, isNull);
+    expect(declaration.extendsClause, isNull);
+    expect(declaration.implementsClause, isNotNull);
+    expect(declaration.classKeyword, isNotNull);
+    expect(declaration.leftBracket, isNotNull);
+    expect(declaration.name, isNotNull);
+    expect(declaration.members, hasLength(0));
+    expect(declaration.rightBracket, isNotNull);
+    expect(declaration.typeParameters, isNull);
+  }
+
+  void test_parseClassDeclaration_metadata() {
+    createParser('@A @B(2) @C.foo(3) @d.E.bar(4, 5) class X {}');
+    var declaration = parseFullCompilationUnitMember() as ClassDeclaration;
+    expect(declaration.metadata, hasLength(4));
+
+    {
+      var annotation = declaration.metadata[0];
+      expect(annotation.atSign, isNotNull);
+      expect(annotation.name, isSimpleIdentifier);
+      expect(annotation.name.name, 'A');
+      expect(annotation.period, isNull);
+      expect(annotation.constructorName, isNull);
+      expect(annotation.arguments, isNull);
+    }
+
+    {
+      var annotation = declaration.metadata[1];
+      expect(annotation.atSign, isNotNull);
+      expect(annotation.name, isSimpleIdentifier);
+      expect(annotation.name.name, 'B');
+      expect(annotation.period, isNull);
+      expect(annotation.constructorName, isNull);
+      expect(annotation.arguments, isNotNull);
+      expect(annotation.arguments.arguments, hasLength(1));
+    }
+
+    {
+      var annotation = declaration.metadata[2];
+      expect(annotation.atSign, isNotNull);
+      expect(annotation.name, isPrefixedIdentifier);
+      expect(annotation.name.name, 'C.foo');
+      expect(annotation.period, isNull);
+      expect(annotation.constructorName, isNull);
+      expect(annotation.arguments, isNotNull);
+      expect(annotation.arguments.arguments, hasLength(1));
+    }
+
+    {
+      var annotation = declaration.metadata[3];
+      expect(annotation.atSign, isNotNull);
+      expect(annotation.name, isPrefixedIdentifier);
+      expect(annotation.name.name, 'd.E');
+      expect(annotation.period, isNotNull);
+      expect(annotation.constructorName, isNotNull);
+      expect(annotation.constructorName.name, 'bar');
+      expect(annotation.arguments, isNotNull);
+      expect(annotation.arguments.arguments, hasLength(2));
+    }
+  }
+
+  void test_parseClassDeclaration_native() {
+    createParser('class A native "nativeValue" {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    if (!allowNativeClause) {
+      assertErrorsWithCodes([
+        ParserErrorCode.NATIVE_CLAUSE_SHOULD_BE_ANNOTATION,
+      ]);
+    } else {
+      assertNoErrors();
+    }
+    expect(member, isClassDeclaration);
+    ClassDeclaration declaration = member;
+    NativeClause nativeClause = declaration.nativeClause;
+    expect(nativeClause, isNotNull);
+    expect(nativeClause.nativeKeyword, isNotNull);
+    expect(nativeClause.name.stringValue, "nativeValue");
+    expect(nativeClause.beginToken, same(nativeClause.nativeKeyword));
+    expect(nativeClause.endToken, same(nativeClause.name.endToken));
+  }
+
+  void test_parseClassDeclaration_native_allowed() {
+    allowNativeClause = true;
+    test_parseClassDeclaration_native();
+  }
+
+  void test_parseClassDeclaration_native_allowedWithFields() {
+    allowNativeClause = true;
+    createParser(r'''
+class A native 'something' {
+  final int x;
+  A() {}
+}
+''');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+  }
+
+  void test_parseClassDeclaration_native_missing_literal() {
+    createParser('class A native {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    if (allowNativeClause) {
+      assertNoErrors();
+    } else {
+      assertErrorsWithCodes([
+        ParserErrorCode.NATIVE_CLAUSE_SHOULD_BE_ANNOTATION,
+      ]);
+    }
+    expect(member, TypeMatcher<ClassDeclaration>());
+    ClassDeclaration declaration = member;
+    expect(declaration.nativeClause, isNotNull);
+    expect(declaration.nativeClause.nativeKeyword, isNotNull);
+    expect(declaration.nativeClause.name, isNull);
+    expect(declaration.endToken.type, TokenType.CLOSE_CURLY_BRACKET);
+  }
+
+  void test_parseClassDeclaration_native_missing_literal_allowed() {
+    allowNativeClause = true;
+    test_parseClassDeclaration_native_missing_literal();
+  }
+
+  void test_parseClassDeclaration_native_missing_literal_not_allowed() {
+    allowNativeClause = false;
+    test_parseClassDeclaration_native_missing_literal();
+  }
+
+  void test_parseClassDeclaration_native_not_allowed() {
+    allowNativeClause = false;
+    test_parseClassDeclaration_native();
+  }
+
+  void test_parseClassDeclaration_nonEmpty() {
+    createParser('class A {var f;}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isClassDeclaration);
+    ClassDeclaration declaration = member;
+    expect(declaration.documentationComment, isNull);
+    expect(declaration.abstractKeyword, isNull);
+    expect(declaration.extendsClause, isNull);
+    expect(declaration.implementsClause, isNull);
+    expect(declaration.classKeyword, isNotNull);
+    expect(declaration.leftBracket, isNotNull);
+    expect(declaration.name, isNotNull);
+    expect(declaration.members, hasLength(1));
+    expect(declaration.rightBracket, isNotNull);
+    expect(declaration.typeParameters, isNull);
+  }
+
+  void test_parseClassDeclaration_typeAlias_implementsC() {
+    createParser('class A = Object with B implements C;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isClassTypeAlias);
+    ClassTypeAlias typeAlias = member;
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name, isNotNull);
+    _assertIsDeclarationName(typeAlias.name);
+    expect(typeAlias.typeParameters, isNull);
+    expect(typeAlias.withClause, isNotNull);
+    expect(typeAlias.implementsClause, isNotNull);
+    expect(typeAlias.implementsClause.implementsKeyword, isNotNull);
+    expect(typeAlias.implementsClause.interfaces.length, 1);
+    expect(typeAlias.semicolon, isNotNull);
+  }
+
+  void test_parseClassDeclaration_typeAlias_withB() {
+    createParser('class A = Object with B;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isClassTypeAlias);
+    ClassTypeAlias typeAlias = member;
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name, isNotNull);
+    expect(typeAlias.typeParameters, isNull);
+    expect(typeAlias.withClause, isNotNull);
+    expect(typeAlias.withClause.withKeyword, isNotNull);
+    expect(typeAlias.withClause.mixinTypes.length, 1);
+    expect(typeAlias.implementsClause, isNull);
+    expect(typeAlias.semicolon, isNotNull);
+  }
+
+  void test_parseClassDeclaration_typeParameters() {
+    createParser('class A<B> {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isClassDeclaration);
+    ClassDeclaration declaration = member;
+    expect(declaration.documentationComment, isNull);
+    expect(declaration.abstractKeyword, isNull);
+    expect(declaration.extendsClause, isNull);
+    expect(declaration.implementsClause, isNull);
+    expect(declaration.classKeyword, isNotNull);
+    expect(declaration.leftBracket, isNotNull);
+    expect(declaration.name, isNotNull);
+    _assertIsDeclarationName(declaration.name);
+    expect(declaration.members, hasLength(0));
+    expect(declaration.rightBracket, isNotNull);
+    expect(declaration.typeParameters, isNotNull);
+    expect(declaration.typeParameters.typeParameters, hasLength(1));
+    _assertIsDeclarationName(declaration.typeParameters.typeParameters[0].name);
+  }
+
+  void test_parseClassDeclaration_typeParameters_extends_void() {
+    parseCompilationUnit('class C<T extends void>{}',
+        errors: [expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 18, 4)]);
+  }
+
+  void test_parseClassDeclaration_withDocumentationComment() {
+    createParser('/// Doc\nclass C {}');
+    var classDeclaration = parseFullCompilationUnitMember() as ClassDeclaration;
+    expectCommentText(classDeclaration.documentationComment, '/// Doc');
+  }
+
+  void test_parseClassTypeAlias_withDocumentationComment() {
+    createParser('/// Doc\nclass C = D with E;');
+    var classTypeAlias = parseFullCompilationUnitMember() as ClassTypeAlias;
+    expectCommentText(classTypeAlias.documentationComment, '/// Doc');
+  }
+
+  void test_parseCompilationUnit_abstractAsPrefix_parameterized() {
+    var errorCodes = <ErrorCode>[];
+    // This used to be deferred to later in the pipeline, but is now being
+    // reported by the parser.
+    errorCodes.add(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE);
+    CompilationUnit unit = parseCompilationUnit(
+        'abstract<dynamic> _abstract = new abstract.A();',
+        codes: errorCodes);
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(1));
+  }
+
+  void test_parseCompilationUnit_builtIn_asFunctionName() {
+    for (Keyword keyword in Keyword.values) {
+      if (keyword.isBuiltIn || keyword.isPseudo) {
+        String lexeme = keyword.lexeme;
+        if (lexeme == 'Function') continue;
+        parseCompilationUnit('$lexeme(x) => 0;');
+        parseCompilationUnit('class C {$lexeme(x) => 0;}');
+      }
+    }
+  }
+
+  void test_parseCompilationUnit_builtIn_asFunctionName_withTypeParameter() {
+    for (Keyword keyword in Keyword.values) {
+      if (keyword.isBuiltIn || keyword.isPseudo) {
+        String lexeme = keyword.lexeme;
+        if (lexeme == 'Function') continue;
+        // The fasta type resolution phase will report an error
+        // on type arguments on `dynamic` (e.g. `dynamic<int>`).
+        parseCompilationUnit('$lexeme<T>(x) => 0;');
+        parseCompilationUnit('class C {$lexeme<T>(x) => 0;}');
+      }
+    }
+  }
+
+  void test_parseCompilationUnit_builtIn_asGetter() {
+    for (Keyword keyword in Keyword.values) {
+      if (keyword.isBuiltIn || keyword.isPseudo) {
+        String lexeme = keyword.lexeme;
+        parseCompilationUnit('get $lexeme => 0;');
+        parseCompilationUnit('class C {get $lexeme => 0;}');
+      }
+    }
+  }
+
+  void test_parseCompilationUnit_directives_multiple() {
+    createParser("library l;\npart 'a.dart';");
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expect(unit, isNotNull);
+    assertNoErrors();
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(2));
+    expect(unit.declarations, hasLength(0));
+  }
+
+  void test_parseCompilationUnit_directives_single() {
+    createParser('library l;');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expect(unit, isNotNull);
+    assertNoErrors();
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(1));
+    expect(unit.declarations, hasLength(0));
+  }
+
+  void test_parseCompilationUnit_empty() {
+    createParser('');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expect(unit, isNotNull);
+    assertNoErrors();
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(0));
+    expect(unit.beginToken, isNotNull);
+    expect(unit.endToken, isNotNull);
+    expect(unit.endToken.type, TokenType.EOF);
+  }
+
+  void test_parseCompilationUnit_exportAsPrefix() {
+    createParser('export.A _export = new export.A();');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expect(unit, isNotNull);
+    assertNoErrors();
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(1));
+  }
+
+  void test_parseCompilationUnit_exportAsPrefix_parameterized() {
+    createParser('export<dynamic> _export = new export.A();');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expect(unit, isNotNull);
+    // This used to be deferred to later in the pipeline, but is now being
+    // reported by the parser.
+    assertErrorsWithCodes([CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE]);
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(1));
+  }
+
+  void test_parseCompilationUnit_operatorAsPrefix_parameterized() {
+    createParser('operator<dynamic> _operator = new operator.A();');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expect(unit, isNotNull);
+    // This used to be deferred to later in the pipeline, but is now being
+    // reported by the parser.
+    assertErrorsWithCodes([CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE]);
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(1));
+  }
+
+  void test_parseCompilationUnit_pseudo_asTypeName() {
+    for (Keyword keyword in Keyword.values) {
+      if (keyword.isPseudo) {
+        String lexeme = keyword.lexeme;
+        parseCompilationUnit('$lexeme f;');
+        parseCompilationUnit('class C {$lexeme f;}');
+        parseCompilationUnit('f($lexeme g) {}');
+        parseCompilationUnit('f() {$lexeme g;}');
+      }
+    }
+  }
+
+  void test_parseCompilationUnit_pseudo_prefixed() {
+    for (Keyword keyword in Keyword.values) {
+      if (keyword.isPseudo) {
+        String lexeme = keyword.lexeme;
+        parseCompilationUnit('M.$lexeme f;');
+        parseCompilationUnit('class C {M.$lexeme f;}');
+      }
+    }
+  }
+
+  void test_parseCompilationUnit_script() {
+    createParser('#! /bin/dart');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expect(unit, isNotNull);
+    assertNoErrors();
+    expect(unit.scriptTag, isNotNull);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(0));
+  }
+
+  void test_parseCompilationUnit_skipFunctionBody_withInterpolation() {
+    ParserTestCase.parseFunctionBodies = false;
+    createParser('f() { "\${n}"; }');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expect(unit, isNotNull);
+    assertNoErrors();
+    expect(unit.scriptTag, isNull);
+    expect(unit.declarations, hasLength(1));
+  }
+
+  void test_parseCompilationUnit_topLevelDeclaration() {
+    createParser('class A {}');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expect(unit, isNotNull);
+    assertNoErrors();
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(1));
+    expect(unit.beginToken, isNotNull);
+    expect(unit.beginToken.keyword, Keyword.CLASS);
+    expect(unit.endToken, isNotNull);
+    expect(unit.endToken.type, TokenType.EOF);
+  }
+
+  void test_parseCompilationUnit_typedefAsPrefix() {
+    createParser('typedef.A _typedef = new typedef.A();');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    expect(unit, isNotNull);
+    assertNoErrors();
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(1));
+  }
+
+  void test_parseCompilationUnitMember_abstractAsPrefix() {
+    createParser('abstract.A _abstract = new abstract.A();');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isTopLevelVariableDeclaration);
+    TopLevelVariableDeclaration declaration = member;
+    expect(declaration.semicolon, isNotNull);
+    expect(declaration.variables, isNotNull);
+  }
+
+  void test_parseCompilationUnitMember_class() {
+    createParser('class A {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isClassDeclaration);
+    ClassDeclaration declaration = member;
+    expect(declaration.name.name, "A");
+    expect(declaration.members, hasLength(0));
+  }
+
+  void test_parseCompilationUnitMember_classTypeAlias() {
+    createParser('abstract class A = B with C;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isClassTypeAlias);
+    ClassTypeAlias declaration = member;
+    expect(declaration.name.name, "A");
+    expect(declaration.abstractKeyword, isNotNull);
+  }
+
+  void test_parseCompilationUnitMember_constVariable() {
+    createParser('const int x = 0;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isTopLevelVariableDeclaration);
+    TopLevelVariableDeclaration declaration = member;
+    expect(declaration.semicolon, isNotNull);
+    expect(declaration.variables, isNotNull);
+    expect(declaration.variables.keyword.lexeme, 'const');
+    _assertIsDeclarationName(declaration.variables.variables[0].name);
+  }
+
+  void test_parseCompilationUnitMember_expressionFunctionBody_tokens() {
+    createParser('f() => 0;');
+    var f = parseFullCompilationUnitMember() as FunctionDeclaration;
+    var body = f.functionExpression.body as ExpressionFunctionBody;
+    expect(body.functionDefinition.lexeme, '=>');
+    expect(body.semicolon.lexeme, ';');
+    _assertIsDeclarationName(f.name);
+  }
+
+  void test_parseCompilationUnitMember_finalVariable() {
+    createParser('final x = 0;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isTopLevelVariableDeclaration);
+    TopLevelVariableDeclaration declaration = member;
+    expect(declaration.semicolon, isNotNull);
+    expect(declaration.variables, isNotNull);
+    expect(declaration.variables.keyword.lexeme, 'final');
+  }
+
+  void test_parseCompilationUnitMember_function_external_noType() {
+    createParser('external f();');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFunctionDeclaration);
+    FunctionDeclaration declaration = member;
+    expect(declaration.externalKeyword, isNotNull);
+    expect(declaration.functionExpression, isNotNull);
+    expect(declaration.propertyKeyword, isNull);
+  }
+
+  void test_parseCompilationUnitMember_function_external_type() {
+    createParser('external int f();');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFunctionDeclaration);
+    FunctionDeclaration declaration = member;
+    expect(declaration.externalKeyword, isNotNull);
+    expect(declaration.functionExpression, isNotNull);
+    expect(declaration.propertyKeyword, isNull);
+  }
+
+  void test_parseCompilationUnitMember_function_generic_noReturnType() {
+    createParser('f<E>() {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFunctionDeclaration);
+    FunctionDeclaration declaration = member;
+    expect(declaration.returnType, isNull);
+    expect(declaration.functionExpression.typeParameters, isNotNull);
+  }
+
+  void
+      test_parseCompilationUnitMember_function_generic_noReturnType_annotated() {
+    createParser('f<@a E>() {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFunctionDeclaration);
+    FunctionDeclaration declaration = member;
+    expect(declaration.returnType, isNull);
+    expect(declaration.functionExpression.typeParameters, isNotNull);
+  }
+
+  void test_parseCompilationUnitMember_function_generic_returnType() {
+    createParser('E f<E>() {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFunctionDeclaration);
+    FunctionDeclaration declaration = member;
+    expect(declaration.returnType, isNotNull);
+    expect(declaration.functionExpression.typeParameters, isNotNull);
+  }
+
+  void test_parseCompilationUnitMember_function_generic_void() {
+    createParser('void f<T>(T t) {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFunctionDeclaration);
+    FunctionDeclaration declaration = member;
+    expect(declaration.functionExpression, isNotNull);
+    expect(declaration.propertyKeyword, isNull);
+  }
+
+  void test_parseCompilationUnitMember_function_gftReturnType() {
+    createParser('''
+void Function<A>(core.List<core.int> x) f() => null;
+''');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    assertNoErrors();
+    expect(unit, isNotNull);
+    expect(unit.declarations, hasLength(1));
+  }
+
+  void test_parseCompilationUnitMember_function_noReturnType() {
+    createParser('''
+Function<A>(core.List<core.int> x) f() => null;
+''');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    assertNoErrors();
+    expect(unit, isNotNull);
+    expect(unit.declarations, hasLength(1));
+  }
+
+  void test_parseCompilationUnitMember_function_noType() {
+    createParser('f() {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFunctionDeclaration);
+    FunctionDeclaration declaration = member;
+    expect(declaration.functionExpression, isNotNull);
+    expect(declaration.propertyKeyword, isNull);
+  }
+
+  void test_parseCompilationUnitMember_function_type() {
+    createParser('int f() {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFunctionDeclaration);
+    FunctionDeclaration declaration = member;
+    expect(declaration.functionExpression, isNotNull);
+    expect(declaration.propertyKeyword, isNull);
+  }
+
+  void test_parseCompilationUnitMember_function_void() {
+    createParser('void f() {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFunctionDeclaration);
+    FunctionDeclaration declaration = member;
+    expect(declaration.returnType, isNotNull);
+  }
+
+  void test_parseCompilationUnitMember_getter_external_noType() {
+    createParser('external get p;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFunctionDeclaration);
+    FunctionDeclaration declaration = member;
+    expect(declaration.externalKeyword, isNotNull);
+    expect(declaration.functionExpression, isNotNull);
+    expect(declaration.propertyKeyword, isNotNull);
+    _assertIsDeclarationName(declaration.name);
+  }
+
+  void test_parseCompilationUnitMember_getter_external_type() {
+    createParser('external int get p;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFunctionDeclaration);
+    FunctionDeclaration declaration = member;
+    expect(declaration.externalKeyword, isNotNull);
+    expect(declaration.functionExpression, isNotNull);
+    expect(declaration.propertyKeyword, isNotNull);
+  }
+
+  void test_parseCompilationUnitMember_getter_noType() {
+    createParser('get p => 0;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFunctionDeclaration);
+    FunctionDeclaration declaration = member;
+    expect(declaration.functionExpression, isNotNull);
+    expect(declaration.propertyKeyword, isNotNull);
+  }
+
+  void test_parseCompilationUnitMember_getter_type() {
+    createParser('int get p => 0;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFunctionDeclaration);
+    FunctionDeclaration declaration = member;
+    expect(declaration.functionExpression, isNotNull);
+    expect(declaration.propertyKeyword, isNotNull);
+  }
+
+  void test_parseCompilationUnitMember_setter_external_noType() {
+    createParser('external set p(v);');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFunctionDeclaration);
+    FunctionDeclaration declaration = member;
+    expect(declaration.externalKeyword, isNotNull);
+    expect(declaration.functionExpression, isNotNull);
+    expect(declaration.propertyKeyword, isNotNull);
+  }
+
+  void test_parseCompilationUnitMember_setter_external_type() {
+    createParser('external void set p(int v);');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFunctionDeclaration);
+    FunctionDeclaration declaration = member;
+    expect(declaration.externalKeyword, isNotNull);
+    expect(declaration.functionExpression, isNotNull);
+    expect(declaration.propertyKeyword, isNotNull);
+  }
+
+  void test_parseCompilationUnitMember_setter_noType() {
+    createParser('set p(v) {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFunctionDeclaration);
+    FunctionDeclaration declaration = member;
+    expect(declaration.functionExpression, isNotNull);
+    expect(declaration.propertyKeyword, isNotNull);
+    _assertIsDeclarationName(declaration.name);
+  }
+
+  void test_parseCompilationUnitMember_setter_type() {
+    createParser('void set p(int v) {}');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isFunctionDeclaration);
+    FunctionDeclaration declaration = member;
+    expect(declaration.functionExpression, isNotNull);
+    expect(declaration.propertyKeyword, isNotNull);
+    expect(declaration.returnType, isNotNull);
+  }
+
+  void test_parseCompilationUnitMember_typeAlias_abstract() {
+    createParser('abstract class C = S with M;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isClassTypeAlias);
+    ClassTypeAlias typeAlias = member;
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name.name, "C");
+    _assertIsDeclarationName(typeAlias.name);
+    expect(typeAlias.typeParameters, isNull);
+    expect(typeAlias.equals, isNotNull);
+    expect(typeAlias.abstractKeyword, isNotNull);
+    expect(typeAlias.superclass.name.name, "S");
+    expect(typeAlias.withClause, isNotNull);
+    expect(typeAlias.implementsClause, isNull);
+    expect(typeAlias.semicolon, isNotNull);
+  }
+
+  void test_parseCompilationUnitMember_typeAlias_generic() {
+    createParser('class C<E> = S<E> with M<E> implements I<E>;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isClassTypeAlias);
+    ClassTypeAlias typeAlias = member;
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name.name, "C");
+    expect(typeAlias.typeParameters.typeParameters, hasLength(1));
+    expect(typeAlias.equals, isNotNull);
+    expect(typeAlias.abstractKeyword, isNull);
+    expect(typeAlias.superclass.name.name, "S");
+    expect(typeAlias.withClause, isNotNull);
+    expect(typeAlias.implementsClause, isNotNull);
+    expect(typeAlias.semicolon, isNotNull);
+  }
+
+  void test_parseCompilationUnitMember_typeAlias_implements() {
+    createParser('class C = S with M implements I;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isClassTypeAlias);
+    ClassTypeAlias typeAlias = member;
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name.name, "C");
+    expect(typeAlias.typeParameters, isNull);
+    expect(typeAlias.equals, isNotNull);
+    expect(typeAlias.abstractKeyword, isNull);
+    expect(typeAlias.superclass.name.name, "S");
+    expect(typeAlias.withClause, isNotNull);
+    expect(typeAlias.implementsClause, isNotNull);
+    expect(typeAlias.semicolon, isNotNull);
+  }
+
+  void test_parseCompilationUnitMember_typeAlias_noImplements() {
+    createParser('class C = S with M;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isClassTypeAlias);
+    ClassTypeAlias typeAlias = member;
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name.name, "C");
+    expect(typeAlias.typeParameters, isNull);
+    expect(typeAlias.equals, isNotNull);
+    expect(typeAlias.abstractKeyword, isNull);
+    expect(typeAlias.superclass.name.name, "S");
+    expect(typeAlias.withClause, isNotNull);
+    expect(typeAlias.implementsClause, isNull);
+    expect(typeAlias.semicolon, isNotNull);
+  }
+
+  void test_parseCompilationUnitMember_typedef() {
+    createParser('typedef F();');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, TypeMatcher<FunctionTypeAlias>());
+    FunctionTypeAlias typeAlias = member;
+    expect(typeAlias.name.name, "F");
+    expect(typeAlias.parameters.parameters, hasLength(0));
+    _assertIsDeclarationName(typeAlias.name);
+  }
+
+  void test_parseCompilationUnitMember_typedef_withDocComment() {
+    createParser('/// Doc\ntypedef F();');
+    var typeAlias = parseFullCompilationUnitMember() as FunctionTypeAlias;
+    expectCommentText(typeAlias.documentationComment, '/// Doc');
+  }
+
+  void test_parseCompilationUnitMember_typedVariable() {
+    createParser('int x = 0;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isTopLevelVariableDeclaration);
+    TopLevelVariableDeclaration declaration = member;
+    expect(declaration.semicolon, isNotNull);
+    expect(declaration.variables, isNotNull);
+    expect(declaration.variables.type, isNotNull);
+    expect(declaration.variables.keyword, isNull);
+    _assertIsDeclarationName(declaration.variables.variables[0].name);
+  }
+
+  void test_parseCompilationUnitMember_variable() {
+    createParser('var x = 0;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isTopLevelVariableDeclaration);
+    TopLevelVariableDeclaration declaration = member;
+    expect(declaration.semicolon, isNotNull);
+    expect(declaration.variables, isNotNull);
+    expect(declaration.variables.keyword.lexeme, 'var');
+  }
+
+  void test_parseCompilationUnitMember_variable_gftType_gftReturnType() {
+    createParser('''
+Function(int) Function(String) v;
+''');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    assertNoErrors();
+    expect(unit, isNotNull);
+    expect(unit.declarations, hasLength(1));
+    TopLevelVariableDeclaration declaration =
+        unit.declarations[0] as TopLevelVariableDeclaration;
+    expect(declaration.variables.type, isGenericFunctionType);
+  }
+
+  void test_parseCompilationUnitMember_variable_gftType_noReturnType() {
+    createParser('''
+Function(int, String) v;
+''');
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    assertNoErrors();
+    expect(unit, isNotNull);
+    expect(unit.declarations, hasLength(1));
+  }
+
+  void test_parseCompilationUnitMember_variable_withDocumentationComment() {
+    createParser('/// Doc\nvar x = 0;');
+    var declaration =
+        parseFullCompilationUnitMember() as TopLevelVariableDeclaration;
+    expectCommentText(declaration.documentationComment, '/// Doc');
+  }
+
+  void test_parseCompilationUnitMember_variableGet() {
+    createParser('String get = null;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isTopLevelVariableDeclaration);
+    TopLevelVariableDeclaration declaration = member;
+    expect(declaration.semicolon, isNotNull);
+    expect(declaration.variables, isNotNull);
+  }
+
+  void test_parseCompilationUnitMember_variableSet() {
+    createParser('String set = null;');
+    CompilationUnitMember member = parseFullCompilationUnitMember();
+    expect(member, isNotNull);
+    assertNoErrors();
+    expect(member, isTopLevelVariableDeclaration);
+    TopLevelVariableDeclaration declaration = member;
+    expect(declaration.semicolon, isNotNull);
+    expect(declaration.variables, isNotNull);
+  }
+
+  void test_parseDirective_export() {
+    createParser("export 'lib/lib.dart';");
+    Directive directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive, TypeMatcher<ExportDirective>());
+    ExportDirective exportDirective = directive;
+    expect(exportDirective.keyword, isNotNull);
+    expect(exportDirective.uri, isNotNull);
+    expect(exportDirective.combinators, hasLength(0));
+    expect(exportDirective.semicolon, isNotNull);
+  }
+
+  void test_parseDirective_export_withDocComment() {
+    createParser("/// Doc\nexport 'foo.dart';");
+    var directive = parseFullDirective() as ExportDirective;
+    expectCommentText(directive.documentationComment, '/// Doc');
+  }
+
+  void test_parseDirective_import() {
+    createParser("import 'lib/lib.dart';");
+    Directive directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive, TypeMatcher<ImportDirective>());
+    ImportDirective importDirective = directive;
+    expect(importDirective.keyword, isNotNull);
+    expect(importDirective.uri, isNotNull);
+    expect(importDirective.asKeyword, isNull);
+    expect(importDirective.prefix, isNull);
+    expect(importDirective.combinators, hasLength(0));
+    expect(importDirective.semicolon, isNotNull);
+  }
+
+  void test_parseDirective_library() {
+    createParser("library l;");
+    Directive directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive, TypeMatcher<LibraryDirective>());
+    LibraryDirective libraryDirective = directive;
+    expect(libraryDirective.libraryKeyword, isNotNull);
+    expect(libraryDirective.name, isNotNull);
+    expect(libraryDirective.semicolon, isNotNull);
+  }
+
+  void test_parseDirective_library_1_component() {
+    createParser("library a;");
+    var lib = parseFullDirective() as LibraryDirective;
+    expect(lib.name.components, hasLength(1));
+    expect(lib.name.components[0].name, 'a');
+  }
+
+  void test_parseDirective_library_2_components() {
+    createParser("library a.b;");
+    var lib = parseFullDirective() as LibraryDirective;
+    expect(lib.name.components, hasLength(2));
+    expect(lib.name.components[0].name, 'a');
+    expect(lib.name.components[1].name, 'b');
+  }
+
+  void test_parseDirective_library_3_components() {
+    createParser("library a.b.c;");
+    var lib = parseFullDirective() as LibraryDirective;
+    expect(lib.name.components, hasLength(3));
+    expect(lib.name.components[0].name, 'a');
+    expect(lib.name.components[1].name, 'b');
+    expect(lib.name.components[2].name, 'c');
+  }
+
+  void test_parseDirective_library_annotation() {
+    createParser("@A library l;");
+    Directive directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive, TypeMatcher<LibraryDirective>());
+    LibraryDirective libraryDirective = directive;
+    expect(libraryDirective.libraryKeyword, isNotNull);
+    expect(libraryDirective.name, isNotNull);
+    expect(libraryDirective.semicolon, isNotNull);
+    expect(libraryDirective.metadata, hasLength(1));
+    expect(libraryDirective.metadata[0].name.name, 'A');
+  }
+
+  void test_parseDirective_library_annotation2() {
+    createParser("@A library l;");
+    CompilationUnit unit = parser.parseCompilationUnit2();
+    Directive directive = unit.directives[0];
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive, TypeMatcher<LibraryDirective>());
+    LibraryDirective libraryDirective = directive;
+    expect(libraryDirective.libraryKeyword, isNotNull);
+    expect(libraryDirective.name, isNotNull);
+    expect(libraryDirective.semicolon, isNotNull);
+    expect(libraryDirective.metadata, hasLength(1));
+    expect(libraryDirective.metadata[0].name.name, 'A');
+  }
+
+  void test_parseDirective_library_withDocumentationComment() {
+    createParser('/// Doc\nlibrary l;');
+    var directive = parseFullDirective() as LibraryDirective;
+    expectCommentText(directive.documentationComment, '/// Doc');
+  }
+
+  void test_parseDirective_part() {
+    createParser("part 'lib/lib.dart';");
+    Directive directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive, TypeMatcher<PartDirective>());
+    PartDirective partDirective = directive;
+    expect(partDirective.partKeyword, isNotNull);
+    expect(partDirective.uri, isNotNull);
+    expect(partDirective.semicolon, isNotNull);
+  }
+
+  void test_parseDirective_part_of_1_component() {
+    createParser("part of a;");
+    var partOf = parseFullDirective() as PartOfDirective;
+    expect(partOf.libraryName.components, hasLength(1));
+    expect(partOf.libraryName.components[0].name, 'a');
+  }
+
+  void test_parseDirective_part_of_2_components() {
+    createParser("part of a.b;");
+    var partOf = parseFullDirective() as PartOfDirective;
+    expect(partOf.libraryName.components, hasLength(2));
+    expect(partOf.libraryName.components[0].name, 'a');
+    expect(partOf.libraryName.components[1].name, 'b');
+  }
+
+  void test_parseDirective_part_of_3_components() {
+    createParser("part of a.b.c;");
+    var partOf = parseFullDirective() as PartOfDirective;
+    expect(partOf.libraryName.components, hasLength(3));
+    expect(partOf.libraryName.components[0].name, 'a');
+    expect(partOf.libraryName.components[1].name, 'b');
+    expect(partOf.libraryName.components[2].name, 'c');
+  }
+
+  void test_parseDirective_part_of_withDocumentationComment() {
+    createParser('/// Doc\npart of a;');
+    var partOf = parseFullDirective() as PartOfDirective;
+    expectCommentText(partOf.documentationComment, '/// Doc');
+  }
+
+  void test_parseDirective_part_withDocumentationComment() {
+    createParser("/// Doc\npart 'lib.dart';");
+    var directive = parseFullDirective() as PartDirective;
+    expectCommentText(directive.documentationComment, '/// Doc');
+  }
+
+  void test_parseDirective_partOf() {
+    createParser("part of l;");
+    Directive directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive, TypeMatcher<PartOfDirective>());
+    PartOfDirective partOfDirective = directive;
+    expect(partOfDirective.partKeyword, isNotNull);
+    expect(partOfDirective.ofKeyword, isNotNull);
+    expect(partOfDirective.libraryName, isNotNull);
+    expect(partOfDirective.semicolon, isNotNull);
+  }
+
+  void test_parseDirectives_annotations() {
+    CompilationUnit unit =
+        parseDirectives("@A library l; @B import 'foo.dart';");
+    expect(unit.directives, hasLength(2));
+    expect(unit.directives[0].metadata[0].name.name, 'A');
+    expect(unit.directives[1].metadata[0].name.name, 'B');
+  }
+
+  void test_parseDirectives_complete() {
+    CompilationUnit unit =
+        parseDirectives("#! /bin/dart\nlibrary l;\nclass A {}");
+    expect(unit.scriptTag, isNotNull);
+    expect(unit.directives, hasLength(1));
+  }
+
+  void test_parseDirectives_empty() {
+    CompilationUnit unit = parseDirectives("");
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(0));
+  }
+
+  void test_parseDirectives_mixed() {
+    CompilationUnit unit =
+        parseDirectives("library l; class A {} part 'foo.dart';");
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(1));
+  }
+
+  void test_parseDirectives_multiple() {
+    CompilationUnit unit = parseDirectives("library l;\npart 'a.dart';");
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(2));
+  }
+
+  void test_parseDirectives_script() {
+    CompilationUnit unit = parseDirectives("#! /bin/dart");
+    expect(unit.scriptTag, isNotNull);
+    expect(unit.directives, hasLength(0));
+  }
+
+  void test_parseDirectives_single() {
+    CompilationUnit unit = parseDirectives("library l;");
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(1));
+  }
+
+  void test_parseDirectives_topLevelDeclaration() {
+    CompilationUnit unit = parseDirectives("class A {}");
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(0));
+  }
+
+  void test_parseEnumDeclaration_one() {
+    createParser("enum E {ONE}");
+    EnumDeclaration declaration = parseFullCompilationUnitMember();
+    expect(declaration, isNotNull);
+    assertNoErrors();
+    expect(declaration.documentationComment, isNull);
+    expect(declaration.enumKeyword, isNotNull);
+    expect(declaration.leftBracket, isNotNull);
+    expect(declaration.name, isNotNull);
+    expect(declaration.constants, hasLength(1));
+    expect(declaration.rightBracket, isNotNull);
+  }
+
+  void test_parseEnumDeclaration_trailingComma() {
+    createParser("enum E {ONE,}");
+    EnumDeclaration declaration = parseFullCompilationUnitMember();
+    expect(declaration, isNotNull);
+    assertNoErrors();
+    expect(declaration.documentationComment, isNull);
+    expect(declaration.enumKeyword, isNotNull);
+    expect(declaration.leftBracket, isNotNull);
+    expect(declaration.name, isNotNull);
+    expect(declaration.constants, hasLength(1));
+    expect(declaration.rightBracket, isNotNull);
+  }
+
+  void test_parseEnumDeclaration_two() {
+    createParser("enum E {ONE, TWO}");
+    EnumDeclaration declaration = parseFullCompilationUnitMember();
+    expect(declaration, isNotNull);
+    assertNoErrors();
+    expect(declaration.documentationComment, isNull);
+    expect(declaration.enumKeyword, isNotNull);
+    expect(declaration.leftBracket, isNotNull);
+    expect(declaration.name, isNotNull);
+    expect(declaration.constants, hasLength(2));
+    expect(declaration.rightBracket, isNotNull);
+  }
+
+  void test_parseEnumDeclaration_withDocComment_onEnum() {
+    createParser('/// Doc\nenum E {ONE}');
+    var declaration = parseFullCompilationUnitMember() as EnumDeclaration;
+    expectCommentText(declaration.documentationComment, '/// Doc');
+  }
+
+  void test_parseEnumDeclaration_withDocComment_onValue() {
+    createParser('''
+enum E {
+  /// Doc
+  ONE
+}''');
+    var declaration = parseFullCompilationUnitMember() as EnumDeclaration;
+    var value = declaration.constants[0];
+    expectCommentText(value.documentationComment, '/// Doc');
+  }
+
+  void test_parseEnumDeclaration_withDocComment_onValue_annotated() {
+    createParser('''
+enum E {
+  /// Doc
+  @annotation
+  ONE
+}
+''');
+    var declaration = parseFullCompilationUnitMember() as EnumDeclaration;
+    var value = declaration.constants[0];
+    expectCommentText(value.documentationComment, '/// Doc');
+    expect(value.metadata, hasLength(1));
+  }
+
+  void test_parseExportDirective_configuration_multiple() {
+    createParser("export 'lib/lib.dart' if (a) 'b.dart' if (c) 'd.dart';");
+    ExportDirective directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive.keyword, isNotNull);
+    expect(directive.uri, isNotNull);
+    expect(directive.configurations, hasLength(2));
+    expectDottedName(directive.configurations[0].name, ['a']);
+    expectDottedName(directive.configurations[1].name, ['c']);
+    expect(directive.combinators, hasLength(0));
+    expect(directive.semicolon, isNotNull);
+  }
+
+  void test_parseExportDirective_configuration_single() {
+    createParser("export 'lib/lib.dart' if (a.b == 'c.dart') '';");
+    ExportDirective directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive.keyword, isNotNull);
+    expect(directive.uri, isNotNull);
+    expect(directive.configurations, hasLength(1));
+    expectDottedName(directive.configurations[0].name, ['a', 'b']);
+    expect(directive.combinators, hasLength(0));
+    expect(directive.semicolon, isNotNull);
+  }
+
+  void test_parseExportDirective_hide() {
+    createParser("export 'lib/lib.dart' hide A, B;");
+    ExportDirective directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive.keyword, isNotNull);
+    expect(directive.uri, isNotNull);
+    expect(directive.combinators, hasLength(1));
+    expect(directive.semicolon, isNotNull);
+  }
+
+  void test_parseExportDirective_hide_show() {
+    createParser("export 'lib/lib.dart' hide A show B;");
+    ExportDirective directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive.keyword, isNotNull);
+    expect(directive.uri, isNotNull);
+    expect(directive.combinators, hasLength(2));
+    expect(directive.semicolon, isNotNull);
+  }
+
+  void test_parseExportDirective_noCombinator() {
+    createParser("export 'lib/lib.dart';");
+    ExportDirective directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive.keyword, isNotNull);
+    expect(directive.uri, isNotNull);
+    expect(directive.combinators, hasLength(0));
+    expect(directive.semicolon, isNotNull);
+  }
+
+  void test_parseExportDirective_show() {
+    createParser("export 'lib/lib.dart' show A, B;");
+    ExportDirective directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive.keyword, isNotNull);
+    expect(directive.uri, isNotNull);
+    expect(directive.combinators, hasLength(1));
+    expect(directive.semicolon, isNotNull);
+  }
+
+  void test_parseExportDirective_show_hide() {
+    createParser("export 'lib/lib.dart' show B hide A;");
+    ExportDirective directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive.keyword, isNotNull);
+    expect(directive.uri, isNotNull);
+    expect(directive.combinators, hasLength(2));
+    expect(directive.semicolon, isNotNull);
+  }
+
+  void test_parseFunctionDeclaration_function() {
+    createParser('/// Doc\nT f() {}');
+    FunctionDeclaration declaration = parseFullCompilationUnitMember();
+    expect(declaration, isNotNull);
+    assertNoErrors();
+    expectCommentText(declaration.documentationComment, '/// Doc');
+    expect((declaration.returnType as TypeName).name.name, 'T');
+    expect(declaration.name, isNotNull);
+    FunctionExpression expression = declaration.functionExpression;
+    expect(expression, isNotNull);
+    expect(expression.body, isNotNull);
+    expect(expression.typeParameters, isNull);
+    expect(expression.parameters, isNotNull);
+    expect(declaration.propertyKeyword, isNull);
+  }
+
+  void test_parseFunctionDeclaration_functionWithTypeParameters() {
+    createParser('/// Doc\nT f<E>() {}');
+    FunctionDeclaration declaration = parseFullCompilationUnitMember();
+    expect(declaration, isNotNull);
+    assertNoErrors();
+    expectCommentText(declaration.documentationComment, '/// Doc');
+    expect((declaration.returnType as TypeName).name.name, 'T');
+    expect(declaration.name, isNotNull);
+    FunctionExpression expression = declaration.functionExpression;
+    expect(expression, isNotNull);
+    expect(expression.body, isNotNull);
+    expect(expression.typeParameters, isNotNull);
+    expect(expression.parameters, isNotNull);
+    expect(declaration.propertyKeyword, isNull);
+  }
+
+  void test_parseFunctionDeclaration_getter() {
+    createParser('/// Doc\nT get p => 0;');
+    FunctionDeclaration declaration = parseFullCompilationUnitMember();
+    expect(declaration, isNotNull);
+    assertNoErrors();
+    expectCommentText(declaration.documentationComment, '/// Doc');
+    expect((declaration.returnType as TypeName).name.name, 'T');
+    expect(declaration.name, isNotNull);
+    FunctionExpression expression = declaration.functionExpression;
+    expect(expression, isNotNull);
+    expect(expression.body, isNotNull);
+    expect(expression.typeParameters, isNull);
+    expect(expression.parameters, isNull);
+    expect(declaration.propertyKeyword, isNotNull);
+  }
+
+  void test_parseFunctionDeclaration_metadata() {
+    createParser(
+        'T f(@A a, @B(2) Foo b, {@C.foo(3) c : 0, @d.E.bar(4, 5) x:0}) {}');
+    FunctionDeclaration declaration = parseFullCompilationUnitMember();
+    expect(declaration, isNotNull);
+    assertNoErrors();
+    expect(declaration.documentationComment, isNull);
+    expect((declaration.returnType as TypeName).name.name, 'T');
+    expect(declaration.name, isNotNull);
+    FunctionExpression expression = declaration.functionExpression;
+    expect(expression, isNotNull);
+    expect(expression.body, isNotNull);
+    expect(expression.typeParameters, isNull);
+    NodeList<FormalParameter> parameters = expression.parameters.parameters;
+    expect(parameters, hasLength(4));
+    expect(declaration.propertyKeyword, isNull);
+
+    {
+      var annotation = parameters[0].metadata[0];
+      expect(annotation.atSign, isNotNull);
+      expect(annotation.name, isSimpleIdentifier);
+      expect(annotation.name.name, 'A');
+      expect(annotation.period, isNull);
+      expect(annotation.constructorName, isNull);
+      expect(annotation.arguments, isNull);
+    }
+
+    {
+      var annotation = parameters[1].metadata[0];
+      expect(annotation.atSign, isNotNull);
+      expect(annotation.name, isSimpleIdentifier);
+      expect(annotation.name.name, 'B');
+      expect(annotation.period, isNull);
+      expect(annotation.constructorName, isNull);
+      expect(annotation.arguments, isNotNull);
+      expect(annotation.arguments.arguments, hasLength(1));
+    }
+
+    {
+      var annotation = parameters[2].metadata[0];
+      expect(annotation.atSign, isNotNull);
+      expect(annotation.name, isPrefixedIdentifier);
+      expect(annotation.name.name, 'C.foo');
+      expect(annotation.period, isNull);
+      expect(annotation.constructorName, isNull);
+      expect(annotation.arguments, isNotNull);
+      expect(annotation.arguments.arguments, hasLength(1));
+    }
+
+    {
+      var annotation = parameters[3].metadata[0];
+      expect(annotation.atSign, isNotNull);
+      expect(annotation.name, isPrefixedIdentifier);
+      expect(annotation.name.name, 'd.E');
+      expect(annotation.period, isNotNull);
+      expect(annotation.constructorName, isNotNull);
+      expect(annotation.constructorName.name, 'bar');
+      expect(annotation.arguments, isNotNull);
+      expect(annotation.arguments.arguments, hasLength(2));
+    }
+  }
+
+  void test_parseFunctionDeclaration_setter() {
+    createParser('/// Doc\nT set p(v) {}');
+    FunctionDeclaration declaration = parseFullCompilationUnitMember();
+    expect(declaration, isNotNull);
+    assertNoErrors();
+    expectCommentText(declaration.documentationComment, '/// Doc');
+    expect((declaration.returnType as TypeName).name.name, 'T');
+    expect(declaration.name, isNotNull);
+    FunctionExpression expression = declaration.functionExpression;
+    expect(expression, isNotNull);
+    expect(expression.body, isNotNull);
+    expect(expression.typeParameters, isNull);
+    expect(expression.parameters, isNotNull);
+    expect(declaration.propertyKeyword, isNotNull);
+  }
+
+  void test_parseGenericTypeAlias_noTypeParameters() {
+    createParser('typedef F = int Function(int);');
+    GenericTypeAlias alias = parseFullCompilationUnitMember();
+    expect(alias, isNotNull);
+    assertNoErrors();
+    expect(alias.name, isNotNull);
+    expect(alias.name.name, 'F');
+    expect(alias.typeParameters, isNull);
+    expect(alias.equals, isNotNull);
+    expect(alias.functionType, isNotNull);
+    expect(alias.semicolon, isNotNull);
+  }
+
+  void test_parseGenericTypeAlias_typeParameters() {
+    createParser('typedef F<T> = T Function(T);');
+    GenericTypeAlias alias = parseFullCompilationUnitMember();
+    expect(alias, isNotNull);
+    assertNoErrors();
+    expect(alias.name, isNotNull);
+    expect(alias.name.name, 'F');
+    expect(alias.typeParameters.typeParameters, hasLength(1));
+    expect(alias.equals, isNotNull);
+    expect(alias.functionType, isNotNull);
+    expect(alias.semicolon, isNotNull);
+  }
+
+  void test_parseGenericTypeAlias_typeParameters2() {
+    // The scanner creates a single token for `>=`
+    // then the parser must split it into two separate tokens.
+    createParser('typedef F<T>= T Function(T);');
+    GenericTypeAlias alias = parseFullCompilationUnitMember();
+    expect(alias, isNotNull);
+    assertNoErrors();
+    expect(alias.name, isNotNull);
+    expect(alias.name.name, 'F');
+    expect(alias.typeParameters.typeParameters, hasLength(1));
+    expect(alias.equals, isNotNull);
+    expect(alias.functionType, isNotNull);
+    expect(alias.semicolon, isNotNull);
+  }
+
+  void test_parseGenericTypeAlias_typeParameters3() {
+    createParser('typedef F<A,B,C> = Function(A a, B b, C c);');
+    GenericTypeAlias alias = parseFullCompilationUnitMember();
+    expect(alias, isNotNull);
+    assertNoErrors();
+    expect(alias.name, isNotNull);
+    expect(alias.name.name, 'F');
+    expect(alias.typeParameters.typeParameters, hasLength(3));
+    expect(alias.equals, isNotNull);
+    expect(alias.functionType, isNotNull);
+    expect(alias.semicolon, isNotNull);
+  }
+
+  void test_parseGenericTypeAlias_typeParameters3_gtEq() {
+    // The scanner creates a single token for `>=`
+    // then the parser must split it into two separate tokens.
+    createParser('typedef F<A,B,C>=Function(A a, B b, C c);');
+    GenericTypeAlias alias = parseFullCompilationUnitMember();
+    expect(alias, isNotNull);
+    assertNoErrors();
+    expect(alias.name, isNotNull);
+    expect(alias.name.name, 'F');
+    expect(alias.typeParameters.typeParameters, hasLength(3));
+    expect(alias.equals, isNotNull);
+    expect(alias.functionType, isNotNull);
+    expect(alias.semicolon, isNotNull);
+  }
+
+  void test_parseGenericTypeAlias_typeParameters_extends() {
+    createParser('typedef F<A,B,C extends D<E>> = Function(A a, B b, C c);');
+    GenericTypeAlias alias = parseFullCompilationUnitMember();
+    expect(alias, isNotNull);
+    assertNoErrors();
+    expect(alias.name, isNotNull);
+    expect(alias.name.name, 'F');
+    expect(alias.typeParameters.typeParameters, hasLength(3));
+    TypeParameter typeParam = alias.typeParameters.typeParameters[2];
+    NamedType type = typeParam.bound;
+    expect(type.typeArguments.arguments, hasLength(1));
+    expect(alias.equals, isNotNull);
+    expect(alias.functionType, isNotNull);
+    expect(alias.semicolon, isNotNull);
+  }
+
+  void test_parseGenericTypeAlias_typeParameters_extends3() {
+    createParser(
+        'typedef F<A,B,C extends D<E,G,H>> = Function(A a, B b, C c);');
+    GenericTypeAlias alias = parseFullCompilationUnitMember();
+    expect(alias, isNotNull);
+    assertNoErrors();
+    expect(alias.name, isNotNull);
+    expect(alias.name.name, 'F');
+    expect(alias.typeParameters.typeParameters, hasLength(3));
+    TypeParameter typeParam = alias.typeParameters.typeParameters[2];
+    NamedType type = typeParam.bound;
+    expect(type.typeArguments.arguments, hasLength(3));
+    expect(alias.equals, isNotNull);
+    expect(alias.functionType, isNotNull);
+    expect(alias.semicolon, isNotNull);
+  }
+
+  void test_parseGenericTypeAlias_typeParameters_extends3_gtGtEq() {
+    // The scanner creates a single token for `>>=`
+    // then the parser must split it into three separate tokens.
+    createParser('typedef F<A,B,C extends D<E,G,H>>=Function(A a, B b, C c);');
+    GenericTypeAlias alias = parseFullCompilationUnitMember();
+    expect(alias, isNotNull);
+    assertNoErrors();
+    expect(alias.name, isNotNull);
+    expect(alias.name.name, 'F');
+    expect(alias.typeParameters.typeParameters, hasLength(3));
+    TypeParameter typeParam = alias.typeParameters.typeParameters[2];
+    NamedType type = typeParam.bound;
+    expect(type.typeArguments.arguments, hasLength(3));
+    expect(alias.equals, isNotNull);
+    expect(alias.functionType, isNotNull);
+    expect(alias.semicolon, isNotNull);
+  }
+
+  void test_parseGenericTypeAlias_typeParameters_extends_gtGtEq() {
+    // The scanner creates a single token for `>>=`
+    // then the parser must split it into three separate tokens.
+    createParser('typedef F<A,B,C extends D<E>>=Function(A a, B b, C c);');
+    GenericTypeAlias alias = parseFullCompilationUnitMember();
+    expect(alias, isNotNull);
+    assertNoErrors();
+    expect(alias.name, isNotNull);
+    expect(alias.name.name, 'F');
+    expect(alias.typeParameters.typeParameters, hasLength(3));
+    TypeParameter typeParam = alias.typeParameters.typeParameters[2];
+    NamedType type = typeParam.bound;
+    expect(type.typeArguments.arguments, hasLength(1));
+    expect(alias.equals, isNotNull);
+    expect(alias.functionType, isNotNull);
+    expect(alias.semicolon, isNotNull);
+  }
+
+  void test_parseImportDirective_configuration_multiple() {
+    createParser("import 'lib/lib.dart' if (a) 'b.dart' if (c) 'd.dart';");
+    ImportDirective directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive.keyword, isNotNull);
+    expect(directive.uri, isNotNull);
+    expect(directive.configurations, hasLength(2));
+    expectDottedName(directive.configurations[0].name, ['a']);
+    expectDottedName(directive.configurations[1].name, ['c']);
+    expect(directive.deferredKeyword, isNull);
+    expect(directive.asKeyword, isNull);
+    expect(directive.prefix, isNull);
+    expect(directive.combinators, hasLength(0));
+    expect(directive.semicolon, isNotNull);
+  }
+
+  void test_parseImportDirective_configuration_single() {
+    createParser("import 'lib/lib.dart' if (a.b == 'c.dart') '';");
+    ImportDirective directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive.keyword, isNotNull);
+    expect(directive.uri, isNotNull);
+    expect(directive.configurations, hasLength(1));
+    expectDottedName(directive.configurations[0].name, ['a', 'b']);
+    expect(directive.deferredKeyword, isNull);
+    expect(directive.asKeyword, isNull);
+    expect(directive.prefix, isNull);
+    expect(directive.combinators, hasLength(0));
+    expect(directive.semicolon, isNotNull);
+  }
+
+  void test_parseImportDirective_deferred() {
+    createParser("import 'lib/lib.dart' deferred as a;");
+    ImportDirective directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive.keyword, isNotNull);
+    expect(directive.uri, isNotNull);
+    expect(directive.deferredKeyword, isNotNull);
+    expect(directive.asKeyword, isNotNull);
+    expect(directive.prefix, isNotNull);
+    expect(directive.combinators, hasLength(0));
+    expect(directive.semicolon, isNotNull);
+  }
+
+  void test_parseImportDirective_hide() {
+    createParser("import 'lib/lib.dart' hide A, B;");
+    ImportDirective directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive.keyword, isNotNull);
+    expect(directive.uri, isNotNull);
+    expect(directive.deferredKeyword, isNull);
+    expect(directive.asKeyword, isNull);
+    expect(directive.prefix, isNull);
+    expect(directive.combinators, hasLength(1));
+    expect(directive.semicolon, isNotNull);
+  }
+
+  void test_parseImportDirective_noCombinator() {
+    createParser("import 'lib/lib.dart';");
+    ImportDirective directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive.keyword, isNotNull);
+    expect(directive.uri, isNotNull);
+    expect(directive.deferredKeyword, isNull);
+    expect(directive.asKeyword, isNull);
+    expect(directive.prefix, isNull);
+    expect(directive.combinators, hasLength(0));
+    expect(directive.semicolon, isNotNull);
+  }
+
+  void test_parseImportDirective_prefix() {
+    createParser("import 'lib/lib.dart' as a;");
+    ImportDirective directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive.keyword, isNotNull);
+    expect(directive.uri, isNotNull);
+    expect(directive.deferredKeyword, isNull);
+    expect(directive.asKeyword, isNotNull);
+    expect(directive.prefix, isNotNull);
+    expect(directive.combinators, hasLength(0));
+    expect(directive.semicolon, isNotNull);
+  }
+
+  void test_parseImportDirective_prefix_hide_show() {
+    createParser("import 'lib/lib.dart' as a hide A show B;");
+    ImportDirective directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive.keyword, isNotNull);
+    expect(directive.uri, isNotNull);
+    expect(directive.deferredKeyword, isNull);
+    expect(directive.asKeyword, isNotNull);
+    expect(directive.prefix, isNotNull);
+    expect(directive.combinators, hasLength(2));
+    expect(directive.semicolon, isNotNull);
+  }
+
+  void test_parseImportDirective_prefix_show_hide() {
+    createParser("import 'lib/lib.dart' as a show B hide A;");
+    ImportDirective directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive.keyword, isNotNull);
+    expect(directive.uri, isNotNull);
+    expect(directive.deferredKeyword, isNull);
+    expect(directive.asKeyword, isNotNull);
+    expect(directive.prefix, isNotNull);
+    expect(directive.combinators, hasLength(2));
+    expect(directive.semicolon, isNotNull);
+  }
+
+  void test_parseImportDirective_show() {
+    createParser("import 'lib/lib.dart' show A, B;");
+    ImportDirective directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive.keyword, isNotNull);
+    expect(directive.uri, isNotNull);
+    expect(directive.deferredKeyword, isNull);
+    expect(directive.asKeyword, isNull);
+    expect(directive.prefix, isNull);
+    expect(directive.combinators, hasLength(1));
+    expect(directive.semicolon, isNotNull);
+  }
+
+  void test_parseLibraryDirective() {
+    createParser('library l;');
+    LibraryDirective directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive.libraryKeyword, isNotNull);
+    expect(directive.name, isNotNull);
+    expect(directive.semicolon, isNotNull);
+  }
+
+  void test_parseMixinDeclaration_empty() {
+    createParser('mixin A {}');
+    MixinDeclaration declaration = parseFullCompilationUnitMember();
+    expect(declaration, isNotNull);
+    assertNoErrors();
+    expect(declaration.metadata, isEmpty);
+    expect(declaration.documentationComment, isNull);
+    expect(declaration.onClause, isNull);
+    expect(declaration.implementsClause, isNull);
+    expect(declaration.mixinKeyword, isNotNull);
+    expect(declaration.leftBracket, isNotNull);
+    expect(declaration.name.name, 'A');
+    expect(declaration.members, hasLength(0));
+    expect(declaration.rightBracket, isNotNull);
+    expect(declaration.typeParameters, isNull);
+  }
+
+  void test_parseMixinDeclaration_implements() {
+    createParser('mixin A implements B {}');
+    MixinDeclaration declaration = parseFullCompilationUnitMember();
+    expect(declaration, isNotNull);
+    assertNoErrors();
+    expect(declaration.metadata, isEmpty);
+    expect(declaration.documentationComment, isNull);
+    expect(declaration.onClause, isNull);
+    ImplementsClause implementsClause = declaration.implementsClause;
+    expect(implementsClause.implementsKeyword, isNotNull);
+    NodeList<TypeName> interfaces = implementsClause.interfaces;
+    expect(interfaces, hasLength(1));
+    expect(interfaces[0].name.name, 'B');
+    expect(interfaces[0].typeArguments, isNull);
+    expect(declaration.mixinKeyword, isNotNull);
+    expect(declaration.leftBracket, isNotNull);
+    expect(declaration.name.name, 'A');
+    expect(declaration.members, hasLength(0));
+    expect(declaration.rightBracket, isNotNull);
+    expect(declaration.typeParameters, isNull);
+  }
+
+  void test_parseMixinDeclaration_implements2() {
+    createParser('mixin A implements B<T>, C {}');
+    MixinDeclaration declaration = parseFullCompilationUnitMember();
+    expect(declaration, isNotNull);
+    assertNoErrors();
+    expect(declaration.metadata, isEmpty);
+    expect(declaration.documentationComment, isNull);
+    expect(declaration.onClause, isNull);
+    ImplementsClause implementsClause = declaration.implementsClause;
+    expect(implementsClause.implementsKeyword, isNotNull);
+    NodeList<TypeName> interfaces = implementsClause.interfaces;
+    expect(interfaces, hasLength(2));
+    expect(interfaces[0].name.name, 'B');
+    expect(interfaces[0].typeArguments.arguments, hasLength(1));
+    expect(interfaces[1].name.name, 'C');
+    expect(interfaces[1].typeArguments, isNull);
+    expect(declaration.mixinKeyword, isNotNull);
+    expect(declaration.leftBracket, isNotNull);
+    expect(declaration.name.name, 'A');
+    expect(declaration.members, hasLength(0));
+    expect(declaration.rightBracket, isNotNull);
+    expect(declaration.typeParameters, isNull);
+  }
+
+  void test_parseMixinDeclaration_metadata() {
+    createParser('@Z mixin A {}');
+    MixinDeclaration declaration = parseFullCompilationUnitMember();
+    expect(declaration, isNotNull);
+    assertNoErrors();
+    NodeList<Annotation> metadata = declaration.metadata;
+    expect(metadata, hasLength(1));
+    expect(metadata[0].name.name, 'Z');
+    expect(declaration.documentationComment, isNull);
+    expect(declaration.onClause, isNull);
+    expect(declaration.implementsClause, isNull);
+    expect(declaration.mixinKeyword, isNotNull);
+    expect(declaration.leftBracket, isNotNull);
+    expect(declaration.name.name, 'A');
+    expect(declaration.members, hasLength(0));
+    expect(declaration.rightBracket, isNotNull);
+    expect(declaration.typeParameters, isNull);
+  }
+
+  void test_parseMixinDeclaration_on() {
+    createParser('mixin A on B {}');
+    MixinDeclaration declaration = parseFullCompilationUnitMember();
+    expect(declaration, isNotNull);
+    assertNoErrors();
+    expect(declaration.metadata, isEmpty);
+    expect(declaration.documentationComment, isNull);
+    OnClause onClause = declaration.onClause;
+    expect(onClause.onKeyword, isNotNull);
+    NodeList<TypeName> constraints = onClause.superclassConstraints;
+    expect(constraints, hasLength(1));
+    expect(constraints[0].name.name, 'B');
+    expect(constraints[0].typeArguments, isNull);
+    expect(declaration.implementsClause, isNull);
+    expect(declaration.mixinKeyword, isNotNull);
+    expect(declaration.leftBracket, isNotNull);
+    expect(declaration.name.name, 'A');
+    expect(declaration.members, hasLength(0));
+    expect(declaration.rightBracket, isNotNull);
+    expect(declaration.typeParameters, isNull);
+  }
+
+  void test_parseMixinDeclaration_on2() {
+    createParser('mixin A on B, C<T> {}');
+    MixinDeclaration declaration = parseFullCompilationUnitMember();
+    expect(declaration, isNotNull);
+    assertNoErrors();
+    expect(declaration.metadata, isEmpty);
+    expect(declaration.documentationComment, isNull);
+    OnClause onClause = declaration.onClause;
+    expect(onClause.onKeyword, isNotNull);
+    NodeList<TypeName> constraints = onClause.superclassConstraints;
+    expect(constraints, hasLength(2));
+    expect(constraints[0].name.name, 'B');
+    expect(constraints[0].typeArguments, isNull);
+    expect(constraints[1].name.name, 'C');
+    expect(constraints[1].typeArguments.arguments, hasLength(1));
+    expect(declaration.implementsClause, isNull);
+    expect(declaration.mixinKeyword, isNotNull);
+    expect(declaration.leftBracket, isNotNull);
+    expect(declaration.name.name, 'A');
+    expect(declaration.members, hasLength(0));
+    expect(declaration.rightBracket, isNotNull);
+    expect(declaration.typeParameters, isNull);
+  }
+
+  void test_parseMixinDeclaration_onAndImplements() {
+    createParser('mixin A on B implements C {}');
+    MixinDeclaration declaration = parseFullCompilationUnitMember();
+    expect(declaration, isNotNull);
+    assertNoErrors();
+    expect(declaration.metadata, isEmpty);
+    expect(declaration.documentationComment, isNull);
+    OnClause onClause = declaration.onClause;
+    expect(onClause.onKeyword, isNotNull);
+    NodeList<TypeName> constraints = onClause.superclassConstraints;
+    expect(constraints, hasLength(1));
+    expect(constraints[0].name.name, 'B');
+    expect(constraints[0].typeArguments, isNull);
+    ImplementsClause implementsClause = declaration.implementsClause;
+    expect(implementsClause.implementsKeyword, isNotNull);
+    NodeList<TypeName> interfaces = implementsClause.interfaces;
+    expect(interfaces, hasLength(1));
+    expect(interfaces[0].name.name, 'C');
+    expect(interfaces[0].typeArguments, isNull);
+    expect(declaration.mixinKeyword, isNotNull);
+    expect(declaration.leftBracket, isNotNull);
+    expect(declaration.name.name, 'A');
+    expect(declaration.members, hasLength(0));
+    expect(declaration.rightBracket, isNotNull);
+    expect(declaration.typeParameters, isNull);
+  }
+
+  void test_parseMixinDeclaration_simple() {
+    createParser('''
+mixin A {
+  int f;
+  int get g => f;
+  set s(int v) {f = v;}
+  int add(int v) => f = f + v;
+}''');
+    MixinDeclaration declaration = parseFullCompilationUnitMember();
+    expect(declaration, isNotNull);
+    assertNoErrors();
+    expect(declaration.metadata, isEmpty);
+    expect(declaration.documentationComment, isNull);
+    expect(declaration.onClause, isNull);
+    expect(declaration.implementsClause, isNull);
+    expect(declaration.mixinKeyword, isNotNull);
+    expect(declaration.leftBracket, isNotNull);
+    expect(declaration.name.name, 'A');
+    expect(declaration.members, hasLength(4));
+    expect(declaration.rightBracket, isNotNull);
+    expect(declaration.typeParameters, isNull);
+  }
+
+  void test_parseMixinDeclaration_withDocumentationComment() {
+    createParser('/// Doc\nmixin M {}');
+    MixinDeclaration declaration = parseFullCompilationUnitMember();
+    expectCommentText(declaration.documentationComment, '/// Doc');
+  }
+
+  void test_parsePartDirective() {
+    createParser("part 'lib/lib.dart';");
+    PartDirective directive = parseFullDirective();
+    expect(directive, isNotNull);
+    assertNoErrors();
+    expect(directive.partKeyword, isNotNull);
+    expect(directive.uri, isNotNull);
+    expect(directive.semicolon, isNotNull);
+  }
+
+  void test_parsePartOfDirective_name() {
+    enableUriInPartOf = true;
+    createParser("part of l;");
+    PartOfDirective directive = parseFullDirective();
+    expect(directive.partKeyword, isNotNull);
+    expect(directive.ofKeyword, isNotNull);
+    expect(directive.libraryName, isNotNull);
+    expect(directive.uri, isNull);
+    expect(directive.semicolon, isNotNull);
+  }
+
+  void test_parsePartOfDirective_uri() {
+    enableUriInPartOf = true;
+    createParser("part of 'lib.dart';");
+    PartOfDirective directive = parseFullDirective();
+    expect(directive.partKeyword, isNotNull);
+    expect(directive.ofKeyword, isNotNull);
+    expect(directive.libraryName, isNull);
+    expect(directive.uri, isNotNull);
+    expect(directive.semicolon, isNotNull);
+  }
+
+  void test_parseTopLevelVariable_external() {
+    var unit = parseCompilationUnit('external int i;', featureSet: nonNullable);
+    var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
+    expect(declaration.externalKeyword, isNotNull);
+  }
+
+  void test_parseTopLevelVariable_external_late() {
+    var unit = parseCompilationUnit('external late int? i;',
+        featureSet: nonNullable,
+        errors: [
+          expectedError(ParserErrorCode.EXTERNAL_LATE_FIELD, 0, 8),
+        ]);
+    var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
+    expect(declaration.externalKeyword, isNotNull);
+  }
+
+  void test_parseTopLevelVariable_external_late_final() {
+    var unit = parseCompilationUnit('external late final int? i;',
+        featureSet: nonNullable,
+        errors: [
+          expectedError(ParserErrorCode.EXTERNAL_LATE_FIELD, 0, 8),
+        ]);
+    var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
+    expect(declaration.externalKeyword, isNotNull);
+  }
+
+  void test_parseTopLevelVariable_final_late() {
+    var unit = parseCompilationUnit('final late a;',
+        featureSet: nonNullable,
+        errors: [expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 6, 4)]);
+    var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
+    var declarationList = declaration.variables;
+    expect(declarationList.keyword.lexeme, 'final');
+    expect(declarationList.type, isNull);
+    expect(declarationList.variables, hasLength(1));
+  }
+
+  void test_parseTopLevelVariable_late() {
+    var unit = parseCompilationUnit('late a;',
+        featureSet: nonNullable,
+        errors: [
+          expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 5, 1)
+        ]);
+    var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
+    var declarationList = declaration.variables;
+    expect(declarationList.keyword, isNull);
+    expect(declarationList.type, isNull);
+    expect(declarationList.variables, hasLength(1));
+  }
+
+  void test_parseTopLevelVariable_late_final() {
+    var unit = parseCompilationUnit('late final a;', featureSet: nonNullable);
+    var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
+    var declarationList = declaration.variables;
+    expect(declarationList.keyword.lexeme, 'final');
+    expect(declarationList.type, isNull);
+    expect(declarationList.variables, hasLength(1));
+  }
+
+  void test_parseTopLevelVariable_late_init() {
+    var unit = parseCompilationUnit('late a = 0;',
+        featureSet: nonNullable,
+        errors: [
+          expectedError(ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, 5, 1)
+        ]);
+    var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
+    var declarationList = declaration.variables;
+    expect(declarationList.keyword, isNull);
+    expect(declarationList.type, isNull);
+    expect(declarationList.variables, hasLength(1));
+  }
+
+  void test_parseTopLevelVariable_late_type() {
+    var unit = parseCompilationUnit('late A a;', featureSet: nonNullable);
+    var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
+    var declarationList = declaration.variables;
+    expect(declarationList.lateKeyword, isNotNull);
+    expect(declarationList.keyword, isNull);
+    expect(declarationList.type, isNotNull);
+    expect(declarationList.variables, hasLength(1));
+  }
+
+  void test_parseTopLevelVariable_non_external() {
+    var unit = parseCompilationUnit('int i;', featureSet: nonNullable);
+    var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
+    expect(declaration.externalKeyword, isNull);
+  }
+
+  void test_parseTypeAlias_function_noParameters() {
+    createParser('typedef bool F();');
+    FunctionTypeAlias typeAlias = parseFullCompilationUnitMember();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name, isNotNull);
+    expect(typeAlias.parameters, isNotNull);
+    expect(typeAlias.returnType, isNotNull);
+    expect(typeAlias.semicolon, isNotNull);
+    expect(typeAlias.typeParameters, isNull);
+  }
+
+  void test_parseTypeAlias_function_noReturnType() {
+    createParser('typedef F();');
+    FunctionTypeAlias typeAlias = parseFullCompilationUnitMember();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name, isNotNull);
+    expect(typeAlias.parameters, isNotNull);
+    expect(typeAlias.returnType, isNull);
+    expect(typeAlias.semicolon, isNotNull);
+    expect(typeAlias.typeParameters, isNull);
+  }
+
+  void test_parseTypeAlias_function_parameterizedReturnType() {
+    createParser('typedef A<B> F();');
+    FunctionTypeAlias typeAlias = parseFullCompilationUnitMember();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name, isNotNull);
+    expect(typeAlias.parameters, isNotNull);
+    expect(typeAlias.returnType, isNotNull);
+    expect(typeAlias.semicolon, isNotNull);
+    expect(typeAlias.typeParameters, isNull);
+  }
+
+  void test_parseTypeAlias_function_parameters() {
+    createParser('typedef bool F(Object value);');
+    FunctionTypeAlias typeAlias = parseFullCompilationUnitMember();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name, isNotNull);
+    expect(typeAlias.parameters, isNotNull);
+    expect(typeAlias.returnType, isNotNull);
+    expect(typeAlias.semicolon, isNotNull);
+    expect(typeAlias.typeParameters, isNull);
+  }
+
+  void test_parseTypeAlias_function_typeParameters() {
+    createParser('typedef bool F<E>();');
+    FunctionTypeAlias typeAlias = parseFullCompilationUnitMember();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name, isNotNull);
+    expect(typeAlias.parameters, isNotNull);
+    expect(typeAlias.returnType, isNotNull);
+    expect(typeAlias.semicolon, isNotNull);
+    expect(typeAlias.typeParameters, isNotNull);
+  }
+
+  void test_parseTypeAlias_function_voidReturnType() {
+    createParser('typedef void F();');
+    FunctionTypeAlias typeAlias = parseFullCompilationUnitMember();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name, isNotNull);
+    expect(typeAlias.parameters, isNotNull);
+    expect(typeAlias.returnType, isNotNull);
+    expect(typeAlias.semicolon, isNotNull);
+    expect(typeAlias.typeParameters, isNull);
+  }
+
+  void test_parseTypeAlias_genericFunction_noParameters() {
+    createParser('typedef F = bool Function();');
+    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name, isNotNull);
+    expect(typeAlias.typeParameters, isNull);
+    expect(typeAlias.semicolon, isNotNull);
+    GenericFunctionType functionType = typeAlias.functionType;
+    expect(functionType, isNotNull);
+    expect(functionType.parameters, isNotNull);
+    expect(functionType.returnType, isNotNull);
+    expect(functionType.typeParameters, isNull);
+  }
+
+  void test_parseTypeAlias_genericFunction_noReturnType() {
+    createParser('typedef F = Function();');
+    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name, isNotNull);
+    expect(typeAlias.typeParameters, isNull);
+    expect(typeAlias.semicolon, isNotNull);
+    GenericFunctionType functionType = typeAlias.functionType;
+    expect(functionType, isNotNull);
+    expect(functionType.parameters, isNotNull);
+    expect(functionType.returnType, isNull);
+    expect(functionType.typeParameters, isNull);
+  }
+
+  void test_parseTypeAlias_genericFunction_parameterizedReturnType() {
+    createParser('typedef F = A<B> Function();');
+    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name, isNotNull);
+    expect(typeAlias.typeParameters, isNull);
+    expect(typeAlias.semicolon, isNotNull);
+    GenericFunctionType functionType = typeAlias.functionType;
+    expect(functionType, isNotNull);
+    expect(functionType.parameters, isNotNull);
+    expect(functionType.returnType, isNotNull);
+    expect(functionType.typeParameters, isNull);
+  }
+
+  void test_parseTypeAlias_genericFunction_parameters() {
+    createParser('typedef F = bool Function(Object value);');
+    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name, isNotNull);
+    expect(typeAlias.typeParameters, isNull);
+    expect(typeAlias.semicolon, isNotNull);
+    GenericFunctionType functionType = typeAlias.functionType;
+    expect(functionType, isNotNull);
+    expect(functionType.parameters, isNotNull);
+    expect(functionType.returnType, isNotNull);
+    expect(functionType.typeParameters, isNull);
+  }
+
+  void test_parseTypeAlias_genericFunction_typeParameters() {
+    createParser('typedef F = bool Function<E>();');
+    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name, isNotNull);
+    expect(typeAlias.typeParameters, isNull);
+    expect(typeAlias.semicolon, isNotNull);
+    GenericFunctionType functionType = typeAlias.functionType;
+    expect(functionType, isNotNull);
+    expect(functionType.parameters, isNotNull);
+    expect(functionType.returnType, isNotNull);
+    expect(functionType.typeParameters, isNotNull);
+  }
+
+  void test_parseTypeAlias_genericFunction_typeParameters_noParameters() {
+    createParser('typedef F<T> = bool Function();');
+    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name, isNotNull);
+    expect(typeAlias.typeParameters, isNotNull);
+    expect(typeAlias.semicolon, isNotNull);
+    GenericFunctionType functionType = typeAlias.functionType;
+    expect(functionType, isNotNull);
+    expect(functionType.parameters, isNotNull);
+    expect(functionType.returnType, isNotNull);
+    expect(functionType.typeParameters, isNull);
+  }
+
+  void test_parseTypeAlias_genericFunction_typeParameters_noReturnType() {
+    createParser('typedef F<T> = Function();');
+    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name, isNotNull);
+    expect(typeAlias.typeParameters, isNotNull);
+    expect(typeAlias.semicolon, isNotNull);
+    GenericFunctionType functionType = typeAlias.functionType;
+    expect(functionType, isNotNull);
+    expect(functionType.parameters, isNotNull);
+    expect(functionType.returnType, isNull);
+    expect(functionType.typeParameters, isNull);
+  }
+
+  void
+      test_parseTypeAlias_genericFunction_typeParameters_parameterizedReturnType() {
+    createParser('typedef F<T> = A<B> Function();');
+    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name, isNotNull);
+    expect(typeAlias.typeParameters, isNotNull);
+    expect(typeAlias.semicolon, isNotNull);
+    GenericFunctionType functionType = typeAlias.functionType;
+    expect(functionType, isNotNull);
+    expect(functionType.parameters, isNotNull);
+    expect(functionType.returnType, isNotNull);
+    expect(functionType.typeParameters, isNull);
+  }
+
+  void test_parseTypeAlias_genericFunction_typeParameters_parameters() {
+    createParser('typedef F<T> = bool Function(Object value);');
+    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name, isNotNull);
+    expect(typeAlias.typeParameters, isNotNull);
+    expect(typeAlias.semicolon, isNotNull);
+    GenericFunctionType functionType = typeAlias.functionType;
+    expect(functionType, isNotNull);
+    expect(functionType.parameters, isNotNull);
+    expect(functionType.returnType, isNotNull);
+    expect(functionType.typeParameters, isNull);
+  }
+
+  void test_parseTypeAlias_genericFunction_typeParameters_typeParameters() {
+    createParser('typedef F<T> = bool Function<E>();');
+    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name, isNotNull);
+    expect(typeAlias.typeParameters, isNotNull);
+    expect(typeAlias.semicolon, isNotNull);
+    GenericFunctionType functionType = typeAlias.functionType;
+    expect(functionType, isNotNull);
+    expect(functionType.parameters, isNotNull);
+    expect(functionType.returnType, isNotNull);
+    expect(functionType.typeParameters, isNotNull);
+  }
+
+  void test_parseTypeAlias_genericFunction_typeParameters_voidReturnType() {
+    createParser('typedef F<T> = void Function();');
+    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name, isNotNull);
+    expect(typeAlias.typeParameters, isNotNull);
+    expect(typeAlias.semicolon, isNotNull);
+    GenericFunctionType functionType = typeAlias.functionType;
+    expect(functionType, isNotNull);
+    expect(functionType.parameters, isNotNull);
+    expect(functionType.returnType, isNotNull);
+    expect(functionType.typeParameters, isNull);
+  }
+
+  void test_parseTypeAlias_genericFunction_voidReturnType() {
+    createParser('typedef F = void Function();');
+    GenericTypeAlias typeAlias = parseFullCompilationUnitMember();
+    expect(typeAlias, isNotNull);
+    assertNoErrors();
+    expect(typeAlias.typedefKeyword, isNotNull);
+    expect(typeAlias.name, isNotNull);
+    expect(typeAlias.typeParameters, isNull);
+    expect(typeAlias.semicolon, isNotNull);
+    GenericFunctionType functionType = typeAlias.functionType;
+    expect(functionType, isNotNull);
+    expect(functionType.parameters, isNotNull);
+    expect(functionType.returnType, isNotNull);
+    expect(functionType.typeParameters, isNull);
+  }
+
+  void test_parseTypeAlias_genericFunction_withDocComment() {
+    createParser('/// Doc\ntypedef F = bool Function();');
+    var typeAlias = parseFullCompilationUnitMember() as GenericTypeAlias;
+    expectCommentText(typeAlias.documentationComment, '/// Doc');
+  }
+
+  void test_parseTypeVariable_withDocumentationComment() {
+    createParser('''
+class A<
+    /// Doc
+    B> {}
+''');
+    var classDeclaration = parseFullCompilationUnitMember() as ClassDeclaration;
+    var typeVariable = classDeclaration.typeParameters.typeParameters[0];
+    expectCommentText(typeVariable.documentationComment, '/// Doc');
+  }
+
+  /// Assert that the given [name] is in declaration context.
+  void _assertIsDeclarationName(SimpleIdentifier name) {
+    expect(name.inDeclarationContext(), isTrue);
+  }
+}
diff --git a/pkg/analyzer/test/generated/variance_parser_test.dart b/pkg/analyzer/test/generated/variance_parser_test.dart
new file mode 100644
index 0000000..256eb10
--- /dev/null
+++ b/pkg/analyzer/test/generated/variance_parser_test.dart
@@ -0,0 +1,185 @@
+// Copyright (c) 2020, 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.
+
+import 'package:analyzer/dart/analysis/features.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/error/error.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/scanner/scanner.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'parser_test_base.dart';
+import 'test_support.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(VarianceParserTest);
+  });
+}
+
+@reflectiveTest
+class VarianceParserTest extends FastaParserTestCase {
+  @override
+  CompilationUnit parseCompilationUnit(String content,
+      {List<ErrorCode> codes,
+      List<ExpectedError> errors,
+      FeatureSet featureSet}) {
+    return super.parseCompilationUnit(content,
+        codes: codes,
+        errors: errors,
+        featureSet: featureSet ??
+            FeatureSet.forTesting(
+              sdkVersion: '2.5.0',
+              additionalFeatures: [Feature.variance],
+            ));
+  }
+
+  void test_class_disabled_multiple() {
+    parseCompilationUnit('class A<in T, inout U, out V> { }',
+        errors: [
+          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 8, 2),
+          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 14, 5),
+          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 23, 3)
+        ],
+        featureSet: FeatureSet.forTesting(sdkVersion: '2.5.0'));
+  }
+
+  void test_class_disabled_single() {
+    parseCompilationUnit('class A<out T> { }',
+        errors: [
+          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 8, 3),
+        ],
+        featureSet: FeatureSet.forTesting(sdkVersion: '2.5.0'));
+  }
+
+  void test_class_enabled_multiple() {
+    var unit = parseCompilationUnit('class A<in T, inout U, out V, W> { }');
+    expect(unit.declarations, hasLength(1));
+    var classDecl = unit.declarations[0] as ClassDeclaration;
+    expect(classDecl.name.name, 'A');
+
+    expect(classDecl.typeParameters.typeParameters, hasLength(4));
+    expect(classDecl.typeParameters.typeParameters[0].name.name, 'T');
+    expect(classDecl.typeParameters.typeParameters[1].name.name, 'U');
+    expect(classDecl.typeParameters.typeParameters[2].name.name, 'V');
+    expect(classDecl.typeParameters.typeParameters[3].name.name, 'W');
+
+    var typeParameterImplList = classDecl.typeParameters.typeParameters;
+    expect((typeParameterImplList[0] as TypeParameterImpl).varianceKeyword,
+        isNotNull);
+    expect(
+        (typeParameterImplList[0] as TypeParameterImpl).varianceKeyword.lexeme,
+        "in");
+    expect((typeParameterImplList[1] as TypeParameterImpl).varianceKeyword,
+        isNotNull);
+    expect(
+        (typeParameterImplList[1] as TypeParameterImpl).varianceKeyword.lexeme,
+        "inout");
+    expect((typeParameterImplList[2] as TypeParameterImpl).varianceKeyword,
+        isNotNull);
+    expect(
+        (typeParameterImplList[2] as TypeParameterImpl).varianceKeyword.lexeme,
+        "out");
+    expect((typeParameterImplList[3] as TypeParameterImpl).varianceKeyword,
+        isNull);
+  }
+
+  void test_class_enabled_multipleVariances() {
+    var unit = parseCompilationUnit('class A<in out inout T> { }', errors: [
+      expectedError(ParserErrorCode.MULTIPLE_VARIANCE_MODIFIERS, 11, 3),
+      expectedError(ParserErrorCode.MULTIPLE_VARIANCE_MODIFIERS, 15, 5)
+    ]);
+    expect(unit.declarations, hasLength(1));
+    var classDecl = unit.declarations[0] as ClassDeclaration;
+    expect(classDecl.name.name, 'A');
+    expect(classDecl.typeParameters.typeParameters, hasLength(1));
+    expect(classDecl.typeParameters.typeParameters[0].name.name, 'T');
+  }
+
+  void test_class_enabled_single() {
+    var unit = parseCompilationUnit('class A<in T> { }');
+    expect(unit.declarations, hasLength(1));
+    var classDecl = unit.declarations[0] as ClassDeclaration;
+    expect(classDecl.name.name, 'A');
+    expect(classDecl.typeParameters.typeParameters, hasLength(1));
+    expect(classDecl.typeParameters.typeParameters[0].name.name, 'T');
+
+    var typeParameterImpl =
+        classDecl.typeParameters.typeParameters[0] as TypeParameterImpl;
+    expect(typeParameterImpl.varianceKeyword, isNotNull);
+    expect(typeParameterImpl.varianceKeyword.lexeme, "in");
+  }
+
+  void test_function_disabled() {
+    parseCompilationUnit('void A(in int value) {}',
+        errors: [
+          expectedError(
+              ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD, 7, 2),
+          expectedError(ParserErrorCode.EXPECTED_TOKEN, 10, 3),
+        ],
+        featureSet: FeatureSet.forTesting(sdkVersion: '2.5.0'));
+  }
+
+  void test_function_enabled() {
+    parseCompilationUnit('void A(in int value) {}', errors: [
+      expectedError(ParserErrorCode.EXPECTED_IDENTIFIER_BUT_GOT_KEYWORD, 7, 2),
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 10, 3),
+    ]);
+  }
+
+  void test_list_disabled() {
+    parseCompilationUnit('List<out String> stringList = [];',
+        errors: [
+          expectedError(ParserErrorCode.EXPECTED_TOKEN, 9, 6),
+        ],
+        featureSet: FeatureSet.forTesting(sdkVersion: '2.5.0'));
+  }
+
+  void test_list_enabled() {
+    parseCompilationUnit('List<out String> stringList = [];', errors: [
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 9, 6),
+    ]);
+  }
+
+  void test_mixin_disabled_multiple() {
+    parseCompilationUnit('mixin A<inout T, out U> { }',
+        errors: [
+          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 8, 5),
+          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 17, 3),
+        ],
+        featureSet: FeatureSet.forTesting(sdkVersion: '2.5.0'));
+  }
+
+  void test_mixin_disabled_single() {
+    parseCompilationUnit('mixin A<inout T> { }',
+        errors: [
+          expectedError(ParserErrorCode.EXPERIMENT_NOT_ENABLED, 8, 5),
+        ],
+        featureSet: FeatureSet.forTesting(sdkVersion: '2.5.0'));
+  }
+
+  void test_mixin_enabled_single() {
+    var unit = parseCompilationUnit('mixin A<inout T> { }');
+    expect(unit.declarations, hasLength(1));
+    var mixinDecl = unit.declarations[0] as MixinDeclaration;
+    expect(mixinDecl.name.name, 'A');
+    expect(mixinDecl.typeParameters.typeParameters, hasLength(1));
+    expect(mixinDecl.typeParameters.typeParameters[0].name.name, 'T');
+  }
+
+  void test_typedef_disabled() {
+    parseCompilationUnit('typedef A<inout X> = X Function(X);',
+        errors: [
+          expectedError(ParserErrorCode.EXPECTED_TOKEN, 16, 1),
+        ],
+        featureSet: FeatureSet.forTesting(sdkVersion: '2.5.0'));
+  }
+
+  void test_typedef_enabled() {
+    parseCompilationUnit('typedef A<inout X> = X Function(X);', errors: [
+      expectedError(ParserErrorCode.EXPECTED_TOKEN, 16, 1),
+    ]);
+  }
+}
diff --git a/pkg/analyzer/test/src/dart/analysis/search_test.dart b/pkg/analyzer/test/src/dart/analysis/search_test.dart
index 1aa797b..c91db90 100644
--- a/pkg/analyzer/test/src/dart/analysis/search_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/search_test.dart
@@ -2,24 +2,20 @@
 // 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.
 
-import 'package:analyzer/dart/analysis/features.dart';
-import 'package:analyzer/dart/analysis/results.dart';
 import 'package:analyzer/dart/ast/ast.dart' hide Declaration;
 import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/src/dart/analysis/driver.dart';
 import 'package:analyzer/src/dart/analysis/search.dart';
-import 'package:analyzer/src/generated/engine.dart';
-import 'package:analyzer/src/generated/testing/element_search.dart';
-import 'package:analyzer/src/test_utilities/find_element.dart';
-import 'package:analyzer/src/test_utilities/find_node.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
-import 'base.dart';
+import '../resolution/context_collection_resolution.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(SearchTest);
     defineReflectiveTests(SearchWithNullSafetyTest);
+    defineReflectiveTests(SearchWithNonFunctionTypeAliasesTest);
   });
 }
 
@@ -66,18 +62,15 @@
 }
 
 @reflectiveTest
-class SearchTest extends BaseAnalysisDriverTest {
-  static const testUri = 'package:test/test.dart';
+class SearchTest extends PubPackageResolutionTest {
+  AnalysisDriver get driver => driverFor(testFilePath);
 
-  CompilationUnit testUnit;
-  CompilationUnitElement testUnitElement;
-  LibraryElement testLibraryElement;
+  CompilationUnitElement get resultUnitElement => result.unit.declaredElement;
 
-  FindNode findNode;
-  FindElement findElement;
+  String get testUriStr => 'package:test/test.dart';
 
   test_classMembers_class() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class A {
   test() {}
 }
@@ -96,14 +89,14 @@
   }
 
   test_classMembers_importNotDart() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 import 'not-dart.txt';
 ''');
     expect(await driver.search.classMembers('test'), isEmpty);
   }
 
   test_classMembers_mixin() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 mixin A {
   test() {}
 }
@@ -122,7 +115,7 @@
   }
 
   test_searchMemberReferences_qualified_resolved() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class C {
   var test;
 }
@@ -137,7 +130,7 @@
   }
 
   test_searchMemberReferences_qualified_unresolved() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 main(p) {
   print(p.test);
   p.test = 1;
@@ -155,7 +148,7 @@
   }
 
   test_searchMemberReferences_unqualified_resolved() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class C {
   var test;
   main() {
@@ -170,7 +163,7 @@
   }
 
   test_searchMemberReferences_unqualified_unresolved() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class C {
   main() {
     print(test);
@@ -190,7 +183,7 @@
   }
 
   test_searchReferences_ClassElement_definedInSdk_declarationSite() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 import 'dart:math';
 Random v1;
 Random v2;
@@ -198,12 +191,7 @@
 
     // Find the Random class element in the SDK source.
     // IDEA performs search always at declaration, never at reference.
-    ClassElement randomElement;
-    {
-      String randomPath = sdk.mapDartUri('dart:math').fullName;
-      ResolvedUnitResult result = await driver.getResult(randomPath);
-      randomElement = result.unit.declaredElement.getType('Random');
-    }
+    var randomElement = findElement.importFind('dart:math').class_('Random');
 
     var v1 = findElement.topVar('v1');
     var v2 = findElement.topVar('v2');
@@ -215,7 +203,7 @@
   }
 
   test_searchReferences_ClassElement_definedInSdk_useSite() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 import 'dart:math';
 Random v1;
 Random v2;
@@ -232,7 +220,7 @@
   }
 
   test_searchReferences_ClassElement_definedInside() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class A {};
 main(A p) {
   A v;
@@ -261,10 +249,10 @@
   }
 
   test_searchReferences_ClassElement_definedOutside() async {
-    newFile('$testProject2/lib.dart', content: r'''
+    newFile('$testPackageLibPath/lib.dart', content: r'''
 class A {};
 ''');
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 import 'lib.dart';
 main(A p) {
   A v;
@@ -281,7 +269,7 @@
   }
 
   test_searchReferences_ClassElement_enum() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 enum MyEnum {a}
 
 main(MyEnum p) {
@@ -304,7 +292,7 @@
   }
 
   test_searchReferences_ClassElement_mixin() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 mixin A {}
 class B extends Object with A {} // with
 ''');
@@ -317,27 +305,26 @@
   }
 
   test_searchReferences_CompilationUnitElement() async {
-    newFile('$testProject2/foo.dart');
-    await _resolveTestUnit('''
+    newFile('$testPackageLibPath/foo.dart');
+    await resolveTestCode('''
 import 'foo.dart'; // import
 export 'foo.dart'; // export
 ''');
-    CompilationUnitElement element =
-        testLibraryElement.imports[0].importedLibrary.definingCompilationUnit;
+    var element = findElement.importFind('package:test/foo.dart').unitElement;
     int uriLength = "'foo.dart'".length;
     var expected = [
-      _expectIdQ(
-          testUnitElement, SearchResultKind.REFERENCE, "'foo.dart'; // import",
+      _expectIdQ(resultUnitElement, SearchResultKind.REFERENCE,
+          "'foo.dart'; // import",
           length: uriLength),
-      _expectIdQ(
-          testUnitElement, SearchResultKind.REFERENCE, "'foo.dart'; // export",
+      _expectIdQ(resultUnitElement, SearchResultKind.REFERENCE,
+          "'foo.dart'; // export",
           length: uriLength),
     ];
     await _verifyReferences(element, expected);
   }
 
   test_searchReferences_ConstructorElement_default() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class A {
   A() {}
 }
@@ -354,7 +341,7 @@
   }
 
   test_searchReferences_ConstructorElement_default_otherFile() async {
-    String other = convertPath('$testProject2/other.dart');
+    String other = convertPath('$testPackageLibPath/other.dart');
     String otherCode = '''
 import 'test.dart';
 main() {
@@ -364,7 +351,7 @@
     newFile(other, content: otherCode);
     driver.addFile(other);
 
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class A {
   A() {}
 }
@@ -382,7 +369,7 @@
   }
 
   test_searchReferences_ConstructorElement_named() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class A {
   A.named() {}
 }
@@ -400,7 +387,7 @@
   }
 
   test_searchReferences_ConstructorElement_synthetic() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class A {
 }
 main() {
@@ -416,7 +403,7 @@
   }
 
   test_searchReferences_ExtensionElement() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 extension E on int {
   void foo() {}
   static void bar() {}
@@ -437,7 +424,7 @@
   }
 
   test_searchReferences_FieldElement() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class A {
   var field;
   A({this.field});
@@ -471,7 +458,7 @@
   }
 
   test_searchReferences_FieldElement_ofEnum() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 enum MyEnum {
   A, B, C
 }
@@ -497,7 +484,7 @@
   }
 
   test_searchReferences_FieldElement_synthetic() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class A {
   get field => null;
   set field(x) {}
@@ -527,7 +514,7 @@
   }
 
   test_searchReferences_FunctionElement() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 test() {}
 main() {
   test();
@@ -544,14 +531,14 @@
   }
 
   test_searchReferences_FunctionElement_local() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 main() {
   test() {}
   test();
   print(test);
 }
 ''');
-    FunctionElement element = findElementsByName(testUnit, 'test').single;
+    var element = findElement.localFunction('test');
     var main = findElement.function('main');
     var expected = [
       _expectId(main, SearchResultKind.INVOCATION, 'test();'),
@@ -561,7 +548,7 @@
   }
 
   test_searchReferences_ImportElement_noPrefix() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 import 'dart:math' show max, pi, Random hide min;
 export 'dart:math' show max, pi, Random hide min;
 main() {
@@ -571,7 +558,7 @@
 }
 Random bar() => null;
 ''');
-    ImportElement element = testLibraryElement.imports[0];
+    var element = findElement.import('dart:math', mustBeUnique: false);
     var main = findElement.function('main');
     var bar = findElement.function('bar');
     var kind = SearchResultKind.REFERENCE;
@@ -585,8 +572,17 @@
   }
 
   test_searchReferences_ImportElement_noPrefix_inPackage() async {
-    testFile = convertPath('/aaa/lib/a.dart');
-    await _resolveTestUnit('''
+    var aaaPackageRootPath = '$packagesRootPath/aaa';
+    var aaaFilePath = convertPath('$aaaPackageRootPath/lib/a.dart');
+
+    writeTestPackageConfig(
+      PackageConfigFileBuilder()
+        ..add(name: 'aaa', rootPath: aaaPackageRootPath),
+    );
+
+    pathForContextSelection = testFilePath;
+
+    await resolveFileCode(aaaFilePath, '''
 import 'dart:math' show max, pi, Random hide min;
 export 'dart:math' show max, pi, Random hide min;
 main() {
@@ -595,8 +591,9 @@
   max(1, 2);
 }
 Random bar() => null;
-''', addToDriver: false);
-    ImportElement element = testLibraryElement.imports[0];
+''');
+
+    ImportElement element = findElement.import('dart:math');
     var main = findElement.function('main');
     var bar = findElement.function('bar');
     var kind = SearchResultKind.REFERENCE;
@@ -610,7 +607,7 @@
   }
 
   test_searchReferences_ImportElement_withPrefix() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 import 'dart:math' as math show max, pi, Random hide min;
 export 'dart:math' show max, pi, Random hide min;
 main() {
@@ -620,7 +617,7 @@
 }
 math.Random bar() => null;
 ''');
-    ImportElement element = testLibraryElement.imports[0];
+    var element = findElement.import('dart:math', mustBeUnique: false);
     var main = findElement.function('main');
     var bar = findElement.function('bar');
     var kind = SearchResultKind.REFERENCE;
@@ -635,7 +632,7 @@
   }
 
   test_searchReferences_ImportElement_withPrefix_forMultipleImports() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 import 'dart:async' as p;
 import 'dart:math' as p;
 main() {
@@ -647,14 +644,14 @@
     var kind = SearchResultKind.REFERENCE;
     var length = 'p.'.length;
     {
-      ImportElement element = testLibraryElement.imports[0];
+      ImportElement element = findElement.import('dart:async');
       var expected = [
         _expectId(main, kind, 'p.Future;', length: length),
       ];
       await _verifyReferences(element, expected);
     }
     {
-      ImportElement element = testLibraryElement.imports[1];
+      ImportElement element = findElement.import('dart:math');
       var expected = [
         _expectId(main, kind, 'p.Random', length: length),
       ];
@@ -663,7 +660,7 @@
   }
 
   test_searchReferences_LabelElement() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 main() {
 label:
   while (true) {
@@ -674,7 +671,7 @@
   }
 }
 ''');
-    Element element = findElementsByName(testUnit, 'label').single;
+    var element = findElement.label('label');
     var main = findElement.function('main');
     var expected = [
       _expectId(main, SearchResultKind.REFERENCE, 'label; // 1'),
@@ -686,14 +683,14 @@
   test_searchReferences_LibraryElement() async {
     var codeA = 'part of lib; // A';
     var codeB = 'part of lib; // B';
-    newFile('$testProject2/unitA.dart', content: codeA);
-    newFile('$testProject2/unitB.dart', content: codeB);
-    await _resolveTestUnit('''
+    newFile('$testPackageLibPath/unitA.dart', content: codeA);
+    newFile('$testPackageLibPath/unitB.dart', content: codeB);
+    await resolveTestCode('''
 library lib;
 part 'unitA.dart';
 part 'unitB.dart';
 ''');
-    LibraryElement element = testLibraryElement;
+    LibraryElement element = result.libraryElement;
     CompilationUnitElement unitElementA = element.parts[0];
     CompilationUnitElement unitElementB = element.parts[1];
     var expected = [
@@ -706,20 +703,30 @@
   }
 
   test_searchReferences_LibraryElement_inPackage() async {
-    testFile = convertPath('/aaa/lib/a.dart');
-    var partPathA = convertPath('/aaa/lib/unitA.dart');
-    var partPathB = convertPath('/aaa/lib/unitB.dart');
+    var aaaPackageRootPath = '$packagesRootPath/aaa';
+
+    writeTestPackageConfig(
+      PackageConfigFileBuilder()
+        ..add(name: 'aaa', rootPath: aaaPackageRootPath),
+    );
+
+    var libPath = convertPath('$aaaPackageRootPath/lib/a.dart');
+    var partPathA = convertPath('$aaaPackageRootPath/lib/unitA.dart');
+    var partPathB = convertPath('$aaaPackageRootPath/lib/unitB.dart');
 
     var codeA = 'part of lib; // A';
     var codeB = 'part of lib; // B';
     newFile(partPathA, content: codeA);
     newFile(partPathB, content: codeB);
-    await _resolveTestUnit('''
+
+    pathForContextSelection = testFilePath;
+
+    await resolveFileCode(libPath, '''
 library lib;
 part 'unitA.dart';
 part 'unitB.dart';
-''', addToDriver: false);
-    LibraryElement element = testLibraryElement;
+''');
+    LibraryElement element = result.libraryElement;
     CompilationUnitElement unitElementA = element.parts[0];
     CompilationUnitElement unitElementB = element.parts[1];
     var expected = [
@@ -732,7 +739,7 @@
   }
 
   test_searchReferences_LocalVariableElement() async {
-    await _resolveTestUnit(r'''
+    await resolveTestCode(r'''
 main() {
   var v;
   v = 1;
@@ -741,7 +748,7 @@
   v();
 }
 ''');
-    Element element = findElementsByName(testUnit, 'v').single;
+    Element element = findElement.localVar('v');
     var main = findElement.function('main');
     var expected = [
       _expectId(main, SearchResultKind.WRITE, 'v = 1;'),
@@ -753,7 +760,7 @@
   }
 
   test_searchReferences_LocalVariableElement_inForEachLoop() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 main() {
   for (var v in []) {
     v = 1;
@@ -763,7 +770,7 @@
   }
 }
 ''');
-    Element element = findElementsByName(testUnit, 'v').single;
+    Element element = findElement.localVar('v');
     var main = findElement.function('main');
     var expected = [
       _expectId(main, SearchResultKind.WRITE, 'v = 1;'),
@@ -775,9 +782,17 @@
   }
 
   test_searchReferences_LocalVariableElement_inPackage() async {
-    testFile = convertPath('/aaa/lib/a.dart');
+    var aaaPackageRootPath = '$packagesRootPath/aaa';
+    var testPath = convertPath('$aaaPackageRootPath/lib/a.dart');
 
-    await _resolveTestUnit('''
+    writeTestPackageConfig(
+      PackageConfigFileBuilder()
+        ..add(name: 'aaa', rootPath: aaaPackageRootPath),
+    );
+
+    pathForContextSelection = testFilePath;
+
+    await resolveFileCode(testPath, '''
 main() {
   var v;
   v = 1;
@@ -785,8 +800,8 @@
   print(v);
   v();
 }
-''', addToDriver: false);
-    Element element = findElementsByName(testUnit, 'v').single;
+''');
+    var element = findElement.localVar('v');
     var main = findElement.function('main');
 
     var expected = [
@@ -799,7 +814,7 @@
   }
 
   test_searchReferences_MethodElement_class() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class A {
   m() {}
   main() {
@@ -822,7 +837,7 @@
   }
 
   test_searchReferences_MethodElement_extension_named() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 extension E on int {
   void foo() {}
 
@@ -846,7 +861,7 @@
   }
 
   test_searchReferences_MethodElement_extension_unnamed() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 extension on int {
   void foo() {}
 
@@ -870,7 +885,7 @@
   }
 
   test_searchReferences_MethodElement_ofExtension_instance() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 extension E on int {
   void foo() {}
 
@@ -906,7 +921,7 @@
   }
 
   test_searchReferences_MethodElement_ofExtension_static() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 extension E on int {
   static void foo() {}
 
@@ -934,7 +949,7 @@
   }
 
   test_searchReferences_MethodMember_class() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class A<T> {
   T m() => null;
 }
@@ -951,7 +966,7 @@
   }
 
   test_searchReferences_ParameterElement_named() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 foo({p}) {
   p = 1;
   p += 2;
@@ -976,7 +991,7 @@
   }
 
   test_searchReferences_ParameterElement_ofConstructor() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class C {
   var f;
   C(p) : f = p + 1 {
@@ -1003,7 +1018,7 @@
   }
 
   test_searchReferences_ParameterElement_ofLocalFunction() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 main() {
   foo(p) {
     p = 1;
@@ -1026,7 +1041,7 @@
   }
 
   test_searchReferences_ParameterElement_ofMethod() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class C {
   foo(p) {
     p = 1;
@@ -1051,7 +1066,7 @@
   }
 
   test_searchReferences_ParameterElement_ofTopLevelFunction() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 foo(p) {
   p = 1;
   p += 2;
@@ -1074,7 +1089,7 @@
   }
 
   test_searchReferences_ParameterElement_optionalPositional() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 foo([p]) {
   p = 1;
   p += 2;
@@ -1103,8 +1118,8 @@
 part of my_lib;
 ppp.Future c;
 ''';
-    newFile('$testProject2/my_part.dart', content: partCode);
-    await _resolveTestUnit('''
+    newFile('$testPackageLibPath/my_part.dart', content: partCode);
+    await resolveTestCode('''
 library my_lib;
 import 'dart:async' as ppp;
 part 'my_part.dart';
@@ -1126,15 +1141,24 @@
   }
 
   test_searchReferences_PrefixElement_inPackage() async {
-    testFile = convertPath('/aaa/lib/a.dart');
-    var partPath = convertPath('/aaa/lib/my_part.dart');
+    var aaaPackageRootPath = '$packagesRootPath/aaa';
+
+    writeTestPackageConfig(
+      PackageConfigFileBuilder()
+        ..add(name: 'aaa', rootPath: aaaPackageRootPath),
+    );
+
+    pathForContextSelection = testFilePath;
+
+    var libPath = convertPath('$aaaPackageRootPath/lib/a.dart');
+    var partPath = convertPath('$aaaPackageRootPath/lib/my_part.dart');
 
     String partCode = r'''
 part of my_lib;
 ppp.Future c;
 ''';
     newFile(partPath, content: partCode);
-    await _resolveTestUnit('''
+    await resolveFileCode(libPath, '''
 library my_lib;
 import 'dart:async' as ppp;
 part 'my_part.dart';
@@ -1142,7 +1166,7 @@
   ppp.Future a;
   ppp.Stream b;
 }
-''', addToDriver: false);
+''');
     var element = findElement.prefix('ppp');
     var main = findElement.function('main');
     var c = findElement.partFind('my_part.dart').topVar('c');
@@ -1156,20 +1180,16 @@
   }
 
   test_searchReferences_private_declaredInDefiningUnit() async {
-    String p1 = convertPath('$testProject2/part1.dart');
-    String p2 = convertPath('$testProject2/part2.dart');
-    String p3 = convertPath('$testProject2/part3.dart');
+    String p1 = convertPath('$testPackageLibPath/part1.dart');
+    String p2 = convertPath('$testPackageLibPath/part2.dart');
+    String p3 = convertPath('$testPackageLibPath/part3.dart');
     String code1 = 'part of lib; _C v1;';
     String code2 = 'part of lib; _C v2;';
     newFile(p1, content: code1);
     newFile(p2, content: code2);
     newFile(p3, content: 'part of lib; int v3;');
 
-    driver.addFile(p1);
-    driver.addFile(p2);
-    driver.addFile(p3);
-
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 library lib;
 part 'part1.dart';
 part 'part2.dart';
@@ -1178,9 +1198,9 @@
 _C v;
 ''');
     var element = findElement.class_('_C');
-    Element v = testUnitElement.topLevelVariables[0];
-    Element v1 = testLibraryElement.parts[0].topLevelVariables[0];
-    Element v2 = testLibraryElement.parts[1].topLevelVariables[0];
+    Element v = findElement.topVar('v');
+    Element v1 = findElement.partFind('part1.dart').topVar('v1');
+    Element v2 = findElement.partFind('part2.dart').topVar('v2');
     var expected = [
       _expectId(v, SearchResultKind.REFERENCE, '_C v;', length: 2),
       ExpectedResult(
@@ -1192,9 +1212,9 @@
   }
 
   test_searchReferences_private_declaredInPart() async {
-    String p = convertPath('$testProject2/lib.dart');
-    String p1 = convertPath('$testProject2/part1.dart');
-    String p2 = convertPath('$testProject2/part2.dart');
+    String p = convertPath('$testPackageLibPath/lib.dart');
+    String p1 = convertPath('$testPackageLibPath/part1.dart');
+    String p2 = convertPath('$testPackageLibPath/part2.dart');
 
     var code = '''
 library lib;
@@ -1213,19 +1233,12 @@
     newFile(p1, content: code1);
     newFile(p2, content: code2);
 
-    driver.addFile(p);
-    driver.addFile(p1);
-    driver.addFile(p2);
+    await resolveTestCode(code);
 
-    ResolvedUnitResult result = await driver.getResult(p);
-    testUnit = result.unit;
-    testUnitElement = testUnit.declaredElement;
-    testLibraryElement = testUnitElement.library;
-
-    ClassElement element = testLibraryElement.parts[0].types[0];
-    Element v = testUnitElement.topLevelVariables[0];
-    Element v1 = testLibraryElement.parts[0].topLevelVariables[0];
-    Element v2 = testLibraryElement.parts[1].topLevelVariables[0];
+    ClassElement element = findElement.partFind('part1.dart').class_('_C');
+    Element v = findElement.topVar('v');
+    Element v1 = findElement.partFind('part1.dart').topVar('v1');
+    Element v2 = findElement.partFind('part2.dart').topVar('v2');
     var expected = [
       ExpectedResult(v, SearchResultKind.REFERENCE, code.indexOf('_C v;'), 2),
       ExpectedResult(
@@ -1237,28 +1250,37 @@
   }
 
   test_searchReferences_private_inPackage() async {
-    testFile = convertPath('/aaa/lib/a.dart');
-    var p1 = convertPath('/aaa/lib/part1.dart');
-    var p2 = convertPath('/aaa/lib/part2.dart');
+    var aaaPackageRootPath = '$packagesRootPath/aaa';
+    var testFile = convertPath('$aaaPackageRootPath/lib/a.dart');
+    var p1 = convertPath('$aaaPackageRootPath/lib/part1.dart');
+    var p2 = convertPath('$aaaPackageRootPath/lib/part2.dart');
 
+    writeTestPackageConfig(
+      PackageConfigFileBuilder()
+        ..add(name: 'aaa', rootPath: aaaPackageRootPath),
+    );
+
+    pathForContextSelection = testFilePath;
+
+    String testCode = '''
+library lib;
+part 'part1.dart';
+part 'part2.dart';
+class _C {}
+_C v;
+''';
     String code1 = 'part of lib; _C v1;';
     String code2 = 'part of lib; _C v2;';
 
     newFile(p1, content: code1);
     newFile(p2, content: code2);
 
-    await _resolveTestUnit('''
-library lib;
-part 'part1.dart';
-part 'part2.dart';
-class _C {}
-_C v;
-''', addToDriver: false);
+    await resolveFileCode(testFile, testCode);
 
-    Element element = testUnitElement.types.single;
-    Element v = testUnitElement.topLevelVariables[0];
-    Element v1 = testLibraryElement.parts[0].topLevelVariables[0];
-    Element v2 = testLibraryElement.parts[1].topLevelVariables[0];
+    ClassElement element = findElement.class_('_C');
+    Element v = findElement.topVar('v');
+    Element v1 = findElement.partFind('part1.dart').topVar('v1');
+    Element v2 = findElement.partFind('part2.dart').topVar('v2');
     var expected = [
       ExpectedResult(
           v, SearchResultKind.REFERENCE, testCode.indexOf('_C v;'), 2),
@@ -1271,7 +1293,7 @@
   }
 
   test_searchReferences_PropertyAccessor_getter_ofExtension_instance() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 extension E on int {
   int get foo => 0;
 
@@ -1299,7 +1321,7 @@
   }
 
   test_searchReferences_PropertyAccessor_setter_ofExtension_instance() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 extension E on int {
   set foo(int _) {}
 
@@ -1327,7 +1349,7 @@
   }
 
   test_searchReferences_PropertyAccessorElement_getter() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class A {
   get ggg => null;
   main() {
@@ -1350,7 +1372,7 @@
   }
 
   test_searchReferences_PropertyAccessorElement_setter() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class A {
   set s(x) {}
   main() {
@@ -1369,11 +1391,11 @@
   }
 
   test_searchReferences_TopLevelVariableElement() async {
-    newFile('$testProject2/lib.dart', content: '''
+    newFile('$testPackageLibPath/lib.dart', content: '''
 library lib;
 var V;
 ''');
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 import 'lib.dart' show V; // imp
 import 'lib.dart' as pref;
 main() {
@@ -1385,13 +1407,13 @@
   V(); // nq
 }
 ''');
-    ImportElement importElement = testLibraryElement.imports[0];
+    ImportElement importElement = findNode.import('show V').element;
     CompilationUnitElement impUnit =
         importElement.importedLibrary.definingCompilationUnit;
     TopLevelVariableElement variable = impUnit.topLevelVariables[0];
     var main = findElement.function('main');
     var expected = [
-      _expectIdQ(testUnitElement, SearchResultKind.REFERENCE, 'V; // imp'),
+      _expectIdQ(resultUnitElement, SearchResultKind.REFERENCE, 'V; // imp'),
       _expectIdQ(main, SearchResultKind.WRITE, 'V = 1; // q'),
       _expectIdQ(main, SearchResultKind.READ, 'V); // q'),
       _expectIdQ(main, SearchResultKind.READ, 'V(); // q'),
@@ -1403,7 +1425,7 @@
   }
 
   test_searchReferences_TypeParameterElement_ofClass() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class A<T> {
   foo(T a) {}
   bar(T b) {}
@@ -1420,7 +1442,7 @@
   }
 
   test_searchReferences_TypeParameterElement_ofLocalFunction() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 main() {
   void foo<T>(T a) {
     void bar(T b) {}
@@ -1438,7 +1460,7 @@
   }
 
   test_searchReferences_TypeParameterElement_ofMethod() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class A {
   foo<T>(T p) {}
 }
@@ -1452,7 +1474,7 @@
   }
 
   test_searchReferences_TypeParameterElement_ofTopLevelFunction() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 foo<T>(T a) {
   bar(T b) {}
 }
@@ -1468,7 +1490,7 @@
   }
 
   test_searchSubtypes() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class T {}
 class A extends T {} // A
 class B = Object with T; // B
@@ -1487,7 +1509,7 @@
   }
 
   test_searchSubtypes_mixinDeclaration() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class T {}
 mixin A on T {} // A
 mixin B implements T {} // B
@@ -1503,7 +1525,7 @@
   }
 
   test_subtypes() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class A {}
 
 class B extends A {
@@ -1535,16 +1557,16 @@
     SubtypeResult c = subtypes.singleWhere((r) => r.name == 'C');
     SubtypeResult d = subtypes.singleWhere((r) => r.name == 'D');
 
-    expect(b.libraryUri, testUri);
-    expect(b.id, '$testUri;$testUri;B');
+    expect(b.libraryUri, testUriStr);
+    expect(b.id, '$testUriStr;$testUriStr;B');
     expect(b.members, ['methodB']);
 
-    expect(c.libraryUri, testUri);
-    expect(c.id, '$testUri;$testUri;C');
+    expect(c.libraryUri, testUriStr);
+    expect(c.id, '$testUriStr;$testUriStr;C');
     expect(c.members, ['methodC']);
 
-    expect(d.libraryUri, testUri);
-    expect(d.id, '$testUri;$testUri;D');
+    expect(d.libraryUri, testUriStr);
+    expect(d.id, '$testUriStr;$testUriStr;D');
     expect(d.members, ['methodD']);
 
     // Search by 'id'.
@@ -1558,15 +1580,23 @@
   }
 
   test_subtypes_discover() async {
-    var pathT = convertPath('/test/lib/t.dart');
-    var pathA = convertPath('/aaa/lib/a.dart');
-    var pathB = convertPath('/bbb/lib/b.dart');
+    var aaaPackageRootPath = '$packagesRootPath/aaa';
+    var bbbPackageRootPath = '$packagesRootPath/bbb';
 
-    var tUri = 'package:test/t.dart';
+    var aaaFilePath = convertPath('$aaaPackageRootPath/lib/a.dart');
+    var bbbFilePath = convertPath('$bbbPackageRootPath/lib/b.dart');
+
+    writeTestPackageConfig(
+      PackageConfigFileBuilder()
+        ..add(name: 'aaa', rootPath: aaaPackageRootPath)
+        ..add(name: 'bbb', rootPath: bbbPackageRootPath),
+    );
+
+    var tUri = 'package:test/test.dart';
     var aUri = 'package:aaa/a.dart';
     var bUri = 'package:bbb/b.dart';
 
-    newFile(pathT, content: r'''
+    newFile(testFilePath, content: r'''
 import 'package:aaa/a.dart';
 
 class T1 extends A {
@@ -1578,7 +1608,7 @@
 }
 ''');
 
-    newFile(pathB, content: r'''
+    newFile(bbbFilePath, content: r'''
 import 'package:aaa/a.dart';
 
 class B extends A {
@@ -1586,15 +1616,13 @@
 }
 ''');
 
-    newFile(pathA, content: r'''
+    newFile(aaaFilePath, content: r'''
 class A {
   void method1() {}
   void method2() {}
 }
 ''');
 
-    driver.addFile(pathT);
-
     var aLibrary = await driver.getLibraryByUri(aUri);
     ClassElement aClass = aLibrary.getType('A');
 
@@ -1621,17 +1649,24 @@
   }
 
   test_subTypes_discover() async {
-    var t = convertPath('/test/lib/t.dart');
-    var a = convertPath('/aaa/lib/a.dart');
-    var b = convertPath('/bbb/lib/b.dart');
-    var c = convertPath('/ccc/lib/c.dart');
+    var aaaPackageRootPath = '$packagesRootPath/aaa';
+    var bbbPackageRootPath = '$packagesRootPath/bbb';
+    var cccPackageRootPath = '$packagesRootPath/ccc';
 
-    newFile(t, content: 'class T implements List {}');
-    newFile(a, content: 'class A implements List {}');
-    newFile(b, content: 'class B implements List {}');
-    newFile(c, content: 'class C implements List {}');
+    var aaaFilePath = convertPath('$aaaPackageRootPath/lib/a.dart');
+    var bbbFilePath = convertPath('$bbbPackageRootPath/lib/b.dart');
+    var cccFilePath = convertPath('$cccPackageRootPath/lib/c.dart');
 
-    driver.addFile(t);
+    writeTestPackageConfig(
+      PackageConfigFileBuilder()
+        ..add(name: 'aaa', rootPath: aaaPackageRootPath)
+        ..add(name: 'bbb', rootPath: bbbPackageRootPath),
+    );
+
+    newFile(testFilePath, content: 'class T implements List {}');
+    newFile(aaaFilePath, content: 'class A implements List {}');
+    newFile(bbbFilePath, content: 'class B implements List {}');
+    newFile(cccFilePath, content: 'class C implements List {}');
 
     LibraryElement coreLib = await driver.getLibraryByUri('dart:core');
     ClassElement listElement = coreLib.getType('List');
@@ -1647,15 +1682,15 @@
       expect(results, not ? isNot(matcher) : matcher);
     }
 
-    assertHasResult(t, 'T');
-    assertHasResult(a, 'A');
-    assertHasResult(b, 'B');
-    assertHasResult(c, 'C', not: true);
+    assertHasResult(convertPath(testFilePath), 'T');
+    assertHasResult(aaaFilePath, 'A');
+    assertHasResult(bbbFilePath, 'B');
+    assertHasResult(cccFilePath, 'C', not: true);
   }
 
   test_subtypes_files() async {
-    String pathB = convertPath('$testProject2/b.dart');
-    String pathC = convertPath('$testProject2/c.dart');
+    String pathB = convertPath('$testPackageLibPath/b.dart');
+    String pathC = convertPath('$testPackageLibPath/c.dart');
     newFile(pathB, content: r'''
 import 'test.dart';
 class B extends A {}
@@ -1666,15 +1701,11 @@
 class D {}
 ''');
 
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class A {}
 ''');
     var a = findElement.class_('A');
 
-    driver.addFile(pathB);
-    driver.addFile(pathC);
-    await scheduler.waitForIdle();
-
     List<SubtypeResult> subtypes =
         await driver.search.subtypes(SearchedFiles(), type: a);
     expect(subtypes, hasLength(2));
@@ -1687,7 +1718,7 @@
   }
 
   test_subtypes_mixin_superclassConstraints() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class A {
   void methodA() {}
 }
@@ -1709,8 +1740,8 @@
       expect(subtypes, hasLength(1));
 
       var m = subtypes.singleWhere((r) => r.name == 'M');
-      expect(m.libraryUri, testUri);
-      expect(m.id, '$testUri;$testUri;M');
+      expect(m.libraryUri, testUriStr);
+      expect(m.id, '$testUriStr;$testUriStr;M');
       expect(m.members, ['methodA', 'methodM']);
     }
 
@@ -1719,14 +1750,14 @@
       expect(subtypes, hasLength(1));
 
       var m = subtypes.singleWhere((r) => r.name == 'M');
-      expect(m.libraryUri, testUri);
-      expect(m.id, '$testUri;$testUri;M');
+      expect(m.libraryUri, testUriStr);
+      expect(m.id, '$testUriStr;$testUriStr;M');
       expect(m.members, ['methodA', 'methodM']);
     }
   }
 
   test_subtypes_partWithoutLibrary() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 part of lib;
 
 class A {}
@@ -1739,12 +1770,12 @@
     expect(subtypes, hasLength(1));
 
     SubtypeResult b = subtypes.singleWhere((r) => r.name == 'B');
-    expect(b.libraryUri, testUri);
-    expect(b.id, '$testUri;$testUri;B');
+    expect(b.libraryUri, testUriStr);
+    expect(b.id, '$testUriStr;$testUriStr;B');
   }
 
   test_topLevelElements() async {
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 class A {} // A
 class B = Object with A;
 mixin C {}
@@ -1767,8 +1798,8 @@
   ExpectedResult _expectId(
       Element enclosingElement, SearchResultKind kind, String search,
       {int length, bool isResolved = true, bool isQualified = false}) {
-    int offset = findOffset(search);
-    length ??= getLeadingIdentifierLength(search);
+    int offset = findNode.offset(search);
+    length ??= findNode.simple(search).length;
     return ExpectedResult(enclosingElement, kind, offset, length,
         isResolved: isResolved, isQualified: isQualified);
   }
@@ -1796,24 +1827,6 @@
         isQualified: false, isResolved: false, length: length);
   }
 
-  Future<void> _resolveTestUnit(String code, {bool addToDriver = true}) async {
-    if (addToDriver) {
-      addTestFile(code);
-    } else {
-      testCode = code;
-      newFile(testFile, content: testCode);
-    }
-    if (testUnit == null) {
-      ResolvedUnitResult result = await driver.getResult(testFile);
-      testUnit = result.unit;
-      testUnitElement = testUnit.declaredElement;
-      testLibraryElement = testUnitElement.library;
-
-      findNode = FindNode(result.content, result.unit);
-      findElement = FindElement(result.unit);
-    }
-  }
-
   Future<void> _verifyNameReferences(
       String name, List<ExpectedResult> expectedMatches) async {
     var searchedFiles = SearchedFiles();
@@ -1838,21 +1851,112 @@
 }
 
 @reflectiveTest
-class SearchWithNullSafetyTest extends SearchTest {
-  @override
-  AnalysisOptionsImpl createAnalysisOptions() => AnalysisOptionsImpl()
-    ..contextFeatures = FeatureSet.forTesting(
-        sdkVersion: '2.7.0', additionalFeatures: [Feature.non_nullable]);
+class SearchWithNonFunctionTypeAliasesTest extends SearchTest
+    with WithNonFunctionTypeAliasesMixin {
+  test_searchReferences_ConstructorElement_named_viaTypeAlias() async {
+    await resolveTestCode('''
+class A<T> {
+  A.named();
+}
 
+typedef B = A<int>;
+
+void f() {
+  B.named(); // ref
+}
+''');
+
+    var element = findElement.constructor('named');
+    var f = findElement.topFunction('f');
+    await _verifyReferences(element, [
+      _expectIdQ(f, SearchResultKind.REFERENCE, '.named(); // ref',
+          length: '.named'.length),
+    ]);
+  }
+
+  test_searchReferences_TypeAliasElement() async {
+    await resolveTestCode('''
+class A<T> {
+  static int field = 0;
+  static void method() {}
+}
+
+typedef B = A<int>;
+
+class C extends B {} // extends
+
+void f(B p) {
+  B v;
+  B.field = 1;
+  B.field;
+  B.method();
+}
+''');
+
+    var element = findElement.typeAlias('B');
+    var f = findElement.topFunction('f');
+    await _verifyReferences(element, [
+      _expectId(findElement.class_('C'), SearchResultKind.REFERENCE,
+          'B {} // extends'),
+      _expectId(findElement.parameter('p'), SearchResultKind.REFERENCE, 'B p'),
+      _expectId(f, SearchResultKind.REFERENCE, 'B v'),
+      _expectId(f, SearchResultKind.REFERENCE, 'B.field ='),
+      _expectId(f, SearchResultKind.REFERENCE, 'B.field;'),
+      _expectId(f, SearchResultKind.REFERENCE, 'B.method();'),
+    ]);
+  }
+
+  test_searchReferences_TypeAliasElement_fromLegacy() async {
+    newFile('$testPackageLibPath/a.dart', content: r'''
+typedef A<T> = Map<int, T>;
+''');
+    await resolveTestCode('''
+// @dart = 2.9
+import 'a.dart';
+
+void f(A<String> a) {}
+''');
+
+    var A = findElement.importFind('package:test/a.dart').typeAlias('A');
+    await _verifyReferences(A, [
+      _expectId(
+        findElement.parameter('a'),
+        SearchResultKind.REFERENCE,
+        'A<String>',
+      ),
+    ]);
+  }
+
+  test_searchReferences_TypeAliasElement_inConstructorName() async {
+    await resolveTestCode('''
+class A<T> {}
+
+typedef B = A<int>;
+
+void f() {
+  B();
+}
+''');
+
+    var element = findElement.typeAlias('B');
+    var f = findElement.topFunction('f');
+    await _verifyReferences(element, [
+      _expectId(f, SearchResultKind.REFERENCE, 'B();'),
+    ]);
+  }
+}
+
+@reflectiveTest
+class SearchWithNullSafetyTest extends SearchTest with WithNullSafetyMixin {
   test_searchReferences_ImportElement_noPrefix_optIn_fromOptOut() async {
-    newFile('/test/lib/a.dart', content: r'''
+    newFile('$testPackageLibPath/a.dart', content: r'''
 class N1 {}
 void N2() {}
 int get N3 => 0;
 set N4(int _) {}
 ''');
 
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 // @dart = 2.7
 import 'a.dart';
 
@@ -1863,7 +1967,7 @@
   N4 = 0;
 }
 ''');
-    ImportElement element = testLibraryElement.imports[0];
+    ImportElement element = findElement.import('package:test/a.dart');
     var main = findElement.function('main');
     var kind = SearchResultKind.REFERENCE;
     var expected = [
@@ -1876,14 +1980,14 @@
   }
 
   test_searchReferences_ImportElement_withPrefix_optIn_fromOptOut() async {
-    newFile('/test/lib/a.dart', content: r'''
+    newFile('$testPackageLibPath/a.dart', content: r'''
 class N1 {}
 void N2() {}
 int get N3 => 0;
 set N4(int _) {}
 ''');
 
-    await _resolveTestUnit('''
+    await resolveTestCode('''
 // @dart = 2.7
 import 'a.dart' as a;
 
@@ -1894,7 +1998,7 @@
   a.N4 = 0;
 }
 ''');
-    ImportElement element = testLibraryElement.imports[0];
+    ImportElement element = findElement.import('package:test/a.dart');
     var main = findElement.function('main');
     var kind = SearchResultKind.REFERENCE;
     var length = 'a.'.length;
diff --git a/pkg/analyzer/test/src/dart/resolution/context_collection_resolution.dart b/pkg/analyzer/test/src/dart/resolution/context_collection_resolution.dart
index 2149a04..8f9f2df 100644
--- a/pkg/analyzer/test/src/dart/resolution/context_collection_resolution.dart
+++ b/pkg/analyzer/test/src/dart/resolution/context_collection_resolution.dart
@@ -136,6 +136,10 @@
   Map<String, String> _declaredVariables = {};
   AnalysisContextCollection _analysisContextCollection;
 
+  /// If not `null`, [resolveFile] will use the context that corresponds
+  /// to this path, instead of the given path.
+  String pathForContextSelection;
+
   List<MockSdkLibrary> get additionalMockSdkLibraries => [];
 
   List<String> get collectionIncludedPaths;
@@ -204,7 +208,7 @@
 
   @override
   Future<ResolvedUnitResult> resolveFile(String path) {
-    var analysisContext = contextFor(path);
+    var analysisContext = contextFor(pathForContextSelection ?? path);
     var session = analysisContext.currentSession;
     return session.getResolvedUnit(path);
   }
@@ -259,6 +263,9 @@
   @override
   List<String> get collectionIncludedPaths => [workspaceRootPath];
 
+  /// The path that is not in [workspaceRootPath], contains external packages.
+  String get packagesRootPath => '/packages';
+
   @override
   String get testFilePath => '$testPackageLibPath/test.dart';
 
diff --git a/pkg/analyzer/test/src/dart/resolution/type_name_test.dart b/pkg/analyzer/test/src/dart/resolution/type_name_test.dart
index f739c14..91aa242 100644
--- a/pkg/analyzer/test/src/dart/resolution/type_name_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/type_name_test.dart
@@ -346,44 +346,6 @@
     );
   }
 
-  test_typeAlias_asParameter_Never_none() async {
-    await assertNoErrorsInCode(r'''
-typedef X = Never;
-void f(X a, X? b) {}
-''');
-
-    assertTypeName(
-      findNode.typeName('X a'),
-      findElement.typeAlias('X'),
-      'Never',
-    );
-
-    assertTypeName(
-      findNode.typeName('X? b'),
-      findElement.typeAlias('X'),
-      'Never?',
-    );
-  }
-
-  test_typeAlias_asParameter_Never_question() async {
-    await assertNoErrorsInCode(r'''
-typedef X = Never?;
-void f(X a, X? b) {}
-''');
-
-    assertTypeName(
-      findNode.typeName('X a'),
-      findElement.typeAlias('X'),
-      'Never?',
-    );
-
-    assertTypeName(
-      findNode.typeName('X? b'),
-      findElement.typeAlias('X'),
-      'Never?',
-    );
-  }
-
   test_typeAlias_asParameterType_interfaceType_none() async {
     await assertNoErrorsInCode(r'''
 typedef X<T> = Map<int, T>;
@@ -403,6 +365,23 @@
     );
   }
 
+  test_typeAlias_asParameterType_interfaceType_none_inLegacy() async {
+    newFile('$testPackageLibPath/a.dart', content: r'''
+typedef X<T> = Map<int, T>;
+''');
+    await assertNoErrorsInCode(r'''
+// @dart = 2.9
+import 'a.dart';
+void f(X<String> a) {}
+''');
+
+    assertTypeName(
+      findNode.typeName('X<String>'),
+      findElement.importFind('package:test/a.dart').typeAlias('X'),
+      'Map<int*, String*>*',
+    );
+  }
+
   test_typeAlias_asParameterType_interfaceType_question() async {
     await assertNoErrorsInCode(r'''
 typedef X<T> = List<T?>;
@@ -422,6 +401,78 @@
     );
   }
 
+  test_typeAlias_asParameterType_interfaceType_question_inLegacy() async {
+    newFile('$testPackageLibPath/a.dart', content: r'''
+typedef X<T> = List<T?>;
+''');
+    await assertNoErrorsInCode(r'''
+// @dart = 2.9
+import 'a.dart';
+void f(X<int> a) {}
+''');
+
+    assertTypeName(
+      findNode.typeName('X<int>'),
+      findElement.importFind('package:test/a.dart').typeAlias('X'),
+      'List<int*>*',
+    );
+  }
+
+  test_typeAlias_asParameterType_Never_none() async {
+    await assertNoErrorsInCode(r'''
+typedef X = Never;
+void f(X a, X? b) {}
+''');
+
+    assertTypeName(
+      findNode.typeName('X a'),
+      findElement.typeAlias('X'),
+      'Never',
+    );
+
+    assertTypeName(
+      findNode.typeName('X? b'),
+      findElement.typeAlias('X'),
+      'Never?',
+    );
+  }
+
+  test_typeAlias_asParameterType_Never_none_inLegacy() async {
+    newFile('$testPackageLibPath/a.dart', content: r'''
+typedef X = Never;
+''');
+    await assertNoErrorsInCode(r'''
+// @dart = 2.9
+import 'a.dart';
+void f(X a) {}
+''');
+
+    assertTypeName(
+      findNode.typeName('X a'),
+      findElement.importFind('package:test/a.dart').typeAlias('X'),
+      'Null*',
+    );
+  }
+
+  test_typeAlias_asParameterType_Never_question() async {
+    await assertNoErrorsInCode(r'''
+typedef X = Never?;
+void f(X a, X? b) {}
+''');
+
+    assertTypeName(
+      findNode.typeName('X a'),
+      findElement.typeAlias('X'),
+      'Never?',
+    );
+
+    assertTypeName(
+      findNode.typeName('X? b'),
+      findElement.typeAlias('X'),
+      'Never?',
+    );
+  }
+
   test_typeAlias_asParameterType_question() async {
     await assertNoErrorsInCode(r'''
 typedef X<T> = T?;
diff --git a/pkg/analyzer/test/src/summary/resynthesize_common.dart b/pkg/analyzer/test/src/summary/resynthesize_common.dart
index a7c9e90..38a8cf3 100644
--- a/pkg/analyzer/test/src/summary/resynthesize_common.dart
+++ b/pkg/analyzer/test/src/summary/resynthesize_common.dart
@@ -12595,6 +12595,22 @@
 ''');
   }
 
+  test_typedef_nonFunction_using_interface_noTypeParameters_legacy() async {
+    featureSet = FeatureSets.nonFunctionTypeAliases;
+    newFile('/a.dart', content: r'''
+typedef A = List<int>;
+''');
+    var library = await checkLibrary(r'''
+// @dart = 2.9
+import 'a.dart';
+void f(A a) {}
+''');
+    checkElementText(library, r'''
+import 'a.dart';
+void f(List<int*>* a) {}
+''');
+  }
+
   test_typedef_nonFunction_using_interface_noTypeParameters_question() async {
     featureSet = FeatureSets.nonFunctionTypeAliases;
     var library = await checkLibrary(r'''
diff --git a/pkg/nnbd_migration/lib/src/preview/preview_site.dart b/pkg/nnbd_migration/lib/src/preview/preview_site.dart
index c67470c..0a58fbe 100644
--- a/pkg/nnbd_migration/lib/src/preview/preview_site.dart
+++ b/pkg/nnbd_migration/lib/src/preview/preview_site.dart
@@ -140,45 +140,30 @@
       }
     }
 
-    if (migratedFiles.isNotEmpty) {
-      var migratedCount = migratedFiles.length;
-      if (migratedCount <= 20) {
-        var s = migratedCount > 1 ? 's' : '';
-        logger.stdout('Migrated $migratedCount file$s:');
-        for (var path in migratedFiles) {
+    _logFileStatus(migratedFiles, (text) => 'Migrated $text');
+    _logFileStatus(
+        newlyOptedOutFiles,
+        (text) =>
+            'Opted $text out of null safety with a new Dart language version '
+            'comment');
+    _logFileStatus(
+        keptOptedOutFiles, (text) => 'Kept $text opted out of null safety');
+  }
+
+  void _logFileStatus(
+      List<String> files, String Function(String text) template) {
+    if (files.isNotEmpty) {
+      var count = files.length;
+      if (count <= 20) {
+        var s = count > 1 ? 's' : '';
+        var text = '$count file$s';
+        logger.stdout('${template(text)}:');
+        for (var path in files) {
           logger.stdout('    $path');
         }
       } else {
-        logger.stdout('Migrated $migratedCount files.');
-      }
-    }
-    if (newlyOptedOutFiles.isNotEmpty) {
-      var newlyOptedOutCount = newlyOptedOutFiles.length;
-      if (newlyOptedOutCount <= 20) {
-        var s = newlyOptedOutCount > 1 ? 's' : '';
-        logger.stdout(
-            'Opted $newlyOptedOutCount file$s out of null safety with a new '
-            'Dart language version comment:');
-        for (var path in newlyOptedOutFiles) {
-          logger.stdout('    $path');
-        }
-      } else {
-        logger.stdout(
-            'Opted $newlyOptedOutCount files out of null safety with a new '
-            'Dart language version comment.');
-      }
-    }
-    if (keptOptedOutFiles.isNotEmpty) {
-      var keptOptedOutCount = keptOptedOutFiles.length;
-      if (keptOptedOutCount <= 20) {
-        var s = keptOptedOutCount > 1 ? 's' : '';
-        logger
-            .stdout('Kept $keptOptedOutCount file$s opted out of null safety:');
-        for (var path in keptOptedOutFiles) {
-          logger.stdout('    $path');
-        }
-      } else {
-        logger.stdout('Kept $keptOptedOutCount files out of null safety.');
+        var text = '$count files';
+        logger.stdout('${template(text)}.');
       }
     }
   }
diff --git a/pkg/nnbd_migration/test/preview/preview_site_test.dart b/pkg/nnbd_migration/test/preview/preview_site_test.dart
index 6312be9..229aac3 100644
--- a/pkg/nnbd_migration/test/preview/preview_site_test.dart
+++ b/pkg/nnbd_migration/test/preview/preview_site_test.dart
@@ -378,7 +378,7 @@
     expect(getFile(path).readAsStringSync(), 'void main() {}');
     expect(logger.stdoutBuffer.toString(), contains('''
 Migrated 1 file:
-    lib/a.dart
+    ${convertPath('lib/a.dart')}
 '''));
   }
 
@@ -398,7 +398,7 @@
     expect(getFile(path).readAsStringSync(), '// @dart=2.9');
     expect(logger.stdoutBuffer.toString(), contains('''
 Opted 1 file out of null safety with a new Dart language version comment:
-    lib/a.dart
+    ${convertPath('lib/a.dart')}
 '''));
   }
 
@@ -425,7 +425,7 @@
 void main() {}''');
     expect(logger.stdoutBuffer.toString(), contains('''
 Opted 1 file out of null safety with a new Dart language version comment:
-    lib/a.dart
+    ${convertPath('lib/a.dart')}
 '''));
   }
 
@@ -448,7 +448,7 @@
 void main() {}''');
     expect(logger.stdoutBuffer.toString(), contains('''
 Opted 1 file out of null safety with a new Dart language version comment:
-    lib/a.dart
+    ${convertPath('lib/a.dart')}
 '''));
   }
 
@@ -485,9 +485,9 @@
 void main(List args) {}''');
     expect(logger.stdoutBuffer.toString(), contains('''
 Migrated 1 file:
-    lib/b.dart
+    ${convertPath('lib/b.dart')}
 Opted 1 file out of null safety with a new Dart language version comment:
-    lib/a.dart
+    ${convertPath('lib/a.dart')}
 '''));
   }
 
@@ -514,7 +514,7 @@
     expect(getFile(path).readAsStringSync(), content);
     expect(logger.stdoutBuffer.toString(), contains('''
 Kept 1 file opted out of null safety:
-    lib/a.dart
+    ${convertPath('lib/a.dart')}
 '''));
   }
 
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler.cc b/runtime/vm/compiler/backend/flow_graph_compiler.cc
index 4809768..13200a2 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler.cc
@@ -2675,8 +2675,9 @@
     // Check if type arguments are null, i.e. equivalent to vector of dynamic.
     __ CompareObject(kTypeArgumentsReg, Object::null_object());
     __ BranchIf(EQUAL, is_instance_lbl);
-    __ LoadFieldFromOffset(kScratchReg, kTypeArgumentsReg,
-                           TypeArguments::type_at_offset(type_param.index()));
+    __ LoadFieldFromOffset(
+        kScratchReg, kTypeArgumentsReg,
+        compiler::target::TypeArguments::type_at_offset(type_param.index()));
     // kScratchReg: Concrete type of type.
     // Check if type argument is dynamic, Object?, or void.
     __ CompareObject(kScratchReg, Object::dynamic_type());
diff --git a/tools/VERSION b/tools/VERSION
index b9ae36a..46c6f42 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 12
 PATCH 0
-PRERELEASE 156
+PRERELEASE 157
 PRERELEASE_PATCH 0
\ No newline at end of file