API clean-up

pkg/analyzer/test/generated/parser_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library engine.parser_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/incremental_scanner.dart';
@@ skipping 107 matching lines @@
 
 /**
  * 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 ParserTestCase {
+  void test_additiveExpression_normal() {
+    BinaryExpression expression = ParserTestCase.parseExpression("x + y - z");
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is BinaryExpression,
+        BinaryExpression,
+        expression.leftOperand);
+  }
+
   void test_additiveExpression_noSpaces() {
     BinaryExpression expression = ParserTestCase.parseExpression("i+1");
     EngineTestCase.assertInstanceOf(
         (obj) => obj is SimpleIdentifier,
         SimpleIdentifier,
         expression.leftOperand);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is IntegerLiteral,
         IntegerLiteral,
         expression.rightOperand);
   }
 
-  void test_additiveExpression_normal() {
-    BinaryExpression expression = ParserTestCase.parseExpression("x + y - z");
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is BinaryExpression,
-        BinaryExpression,
-        expression.leftOperand);
-  }
-
   void test_additiveExpression_precedence_multiplicative_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("x * y + z");
     EngineTestCase.assertInstanceOf(
         (obj) => obj is BinaryExpression,
         BinaryExpression,
         expression.leftOperand);
   }
 
   void test_additiveExpression_precedence_multiplicative_left_withSuper() {
     BinaryExpression expression =
@@ skipping 769 matching lines @@
   }
 
   void test_constMethod() {
     ParserTestCase.parse3(
         "parseClassMember",
         <Object>["C"],
         "const int m() {}",
         [ParserErrorCode.CONST_METHOD]);
   }
 
-  void test_constTypedef() {
-    ParserTestCase.parseCompilationUnit(
-        "const typedef F();",
-        [ParserErrorCode.CONST_TYPEDEF]);
-  }
-
   void test_constructorWithReturnType() {
     ParserTestCase.parse3(
         "parseClassMember",
         <Object>["C"],
         "C C() {}",
         [ParserErrorCode.CONSTRUCTOR_WITH_RETURN_TYPE]);
   }
 
   void test_constructorWithReturnType_var() {
     ParserTestCase.parse3(
         "parseClassMember",
         <Object>["C"],
         "var C() {}",
         [ParserErrorCode.CONSTRUCTOR_WITH_RETURN_TYPE]);
   }
 
+  void test_constTypedef() {
+    ParserTestCase.parseCompilationUnit(
+        "const typedef F();",
+        [ParserErrorCode.CONST_TYPEDEF]);
+  }
+
   void test_continueOutsideOfLoop_continueInDoStatement() {
     ParserTestCase.parse4("parseDoStatement", "do {continue;} while (x);");
   }
 
   void test_continueOutsideOfLoop_continueInForStatement() {
     ParserTestCase.parse4("parseForStatement", "for (; x;) {continue;}");
   }
 
   void test_continueOutsideOfLoop_continueInIfStatement() {
     ParserTestCase.parse4(
@@ skipping 60 matching lines @@
     expect(unit, isNotNull);
   }
 
   void test_directiveAfterDeclaration_classBetweenDirectives() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(
         "library l;\nclass Foo{}\npart 'a.dart';",
         [ParserErrorCode.DIRECTIVE_AFTER_DECLARATION]);
     expect(unit, isNotNull);
   }
 
-  void test_duplicateLabelInSwitchStatement() {
-    ParserTestCase.parse4(
-        "parseSwitchStatement",
-        "switch (e) {l1: case 0: break; l1: case 1: break;}",
-        [ParserErrorCode.DUPLICATE_LABEL_IN_SWITCH_STATEMENT]);
-  }
-
   void test_duplicatedModifier_const() {
     ParserTestCase.parse3(
         "parseClassMember",
         <Object>["C"],
         "const const m;",
         [ParserErrorCode.DUPLICATED_MODIFIER]);
   }
 
   void test_duplicatedModifier_external() {
     ParserTestCase.parse3(
@@ skipping 28 matching lines @@
   }
 
   void test_duplicatedModifier_var() {
     ParserTestCase.parse3(
         "parseClassMember",
         <Object>["C"],
         "var var m;",
         [ParserErrorCode.DUPLICATED_MODIFIER]);
   }
 
+  void test_duplicateLabelInSwitchStatement() {
+    ParserTestCase.parse4(
+        "parseSwitchStatement",
+        "switch (e) {l1: case 0: break; l1: case 1: break;}",
+        [ParserErrorCode.DUPLICATE_LABEL_IN_SWITCH_STATEMENT]);
+  }
+
   void test_emptyEnumBody() {
     ParserTestCase.parse3(
         "parseEnumDeclaration",
         <Object>[emptyCommentAndMetadata()],
         "enum E {}",
         [ParserErrorCode.EMPTY_ENUM_BODY]);
   }
 
   void test_equalityCannotBeEqualityOperand_eq_eq() {
     ParserTestCase.parseExpression(
@@ skipping 649 matching lines @@
 
   void test_missingAssignableSelector_selector() {
     ParserTestCase.parseExpression("x(y)(z).a++");
   }
 
   void test_missingAssignableSelector_superPrimaryExpression() {
     SuperExpression expression = ParserTestCase.parse4(
         "parsePrimaryExpression",
         "super",
         [ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR]);
-    expect(expression.keyword, isNotNull);
+    expect(expression.superKeyword, isNotNull);
   }
 
   void test_missingAssignableSelector_superPropertyAccessAssigned() {
     ParserTestCase.parseExpression("super.x = x;");
   }
 
   void test_missingCatchOrFinally() {
     TryStatement statement = ParserTestCase.parse4(
         "parseTryStatement",
         "try {}",
@@ skipping 567 matching lines @@
 
   void test_switchHasMultipleDefaultCases_repeated() {
     ParserTestCase.parse4(
         "parseSwitchStatement",
         "switch (a) {default: return 0; default: return 1; default: return 2;}",
         [
             ParserErrorCode.SWITCH_HAS_MULTIPLE_DEFAULT_CASES,
             ParserErrorCode.SWITCH_HAS_MULTIPLE_DEFAULT_CASES]);
   }
 
+  void test_topLevelOperator_withoutType() {
+    ParserTestCase.parse3(
+        "parseCompilationUnitMember",
+        <Object>[emptyCommentAndMetadata()],
+        "operator +(bool x, bool y) => x | y;",
+        [ParserErrorCode.TOP_LEVEL_OPERATOR]);
+  }
+
   void test_topLevelOperator_withType() {
     ParserTestCase.parse3(
         "parseCompilationUnitMember",
         <Object>[emptyCommentAndMetadata()],
         "bool operator +(bool x, bool y) => x | y;",
         [ParserErrorCode.TOP_LEVEL_OPERATOR]);
   }
 
   void test_topLevelOperator_withVoid() {
     ParserTestCase.parse3(
         "parseCompilationUnitMember",
         <Object>[emptyCommentAndMetadata()],
         "void operator +(bool x, bool y) => x | y;",
         [ParserErrorCode.TOP_LEVEL_OPERATOR]);
   }
 
-  void test_topLevelOperator_withoutType() {
-    ParserTestCase.parse3(
-        "parseCompilationUnitMember",
-        <Object>[emptyCommentAndMetadata()],
-        "operator +(bool x, bool y) => x | y;",
-        [ParserErrorCode.TOP_LEVEL_OPERATOR]);
+  void test_typedefInClass_withoutReturnType() {
+    ParserTestCase.parseCompilationUnit(
+        "class C { typedef F(x); }",
+        [ParserErrorCode.TYPEDEF_IN_CLASS]);
   }
 
   void test_typedefInClass_withReturnType() {
     ParserTestCase.parseCompilationUnit(
         "class C { typedef int F(int x); }",
         [ParserErrorCode.TYPEDEF_IN_CLASS]);
   }
 
-  void test_typedefInClass_withoutReturnType() {
-    ParserTestCase.parseCompilationUnit(
-        "class C { typedef F(x); }",
-        [ParserErrorCode.TYPEDEF_IN_CLASS]);
-  }
-
   void test_unexpectedTerminatorForParameterGroup_named() {
     ParserTestCase.parse4(
         "parseFormalParameterList",
         "(a, b})",
         [ParserErrorCode.UNEXPECTED_TERMINATOR_FOR_PARAMETER_GROUP]);
   }
 
   void test_unexpectedTerminatorForParameterGroup_optional() {
     ParserTestCase.parse4(
         "parseFormalParameterList",
@@ skipping 99 matching lines @@
   }
 
   void test_voidVariable_parseClassMember_noInitializer() {
     ParserTestCase.parse3(
         "parseClassMember",
         <Object>["C"],
         "void x;",
         [ParserErrorCode.VOID_VARIABLE]);
   }
 
+  void test_voidVariable_parseCompilationUnit_initializer() {
+    ParserTestCase.parseCompilationUnit(
+        "void x = 0;",
+        [ParserErrorCode.VOID_VARIABLE]);
+  }
+
+  void test_voidVariable_parseCompilationUnit_noInitializer() {
+    ParserTestCase.parseCompilationUnit(
+        "void x;",
+        [ParserErrorCode.VOID_VARIABLE]);
+  }
+
   void test_voidVariable_parseCompilationUnitMember_initializer() {
     ParserTestCase.parse3(
         "parseCompilationUnitMember",
         <Object>[emptyCommentAndMetadata()],
         "void a = 0;",
         [ParserErrorCode.VOID_VARIABLE]);
   }
 
   void test_voidVariable_parseCompilationUnitMember_noInitializer() {
     ParserTestCase.parse3(
         "parseCompilationUnitMember",
         <Object>[emptyCommentAndMetadata()],
         "void a;",
         [ParserErrorCode.VOID_VARIABLE]);
   }
 
-  void test_voidVariable_parseCompilationUnit_initializer() {
-    ParserTestCase.parseCompilationUnit(
-        "void x = 0;",
-        [ParserErrorCode.VOID_VARIABLE]);
-  }
-
-  void test_voidVariable_parseCompilationUnit_noInitializer() {
-    ParserTestCase.parseCompilationUnit(
-        "void x;",
-        [ParserErrorCode.VOID_VARIABLE]);
-  }
-
   void test_voidVariable_statement_initializer() {
     ParserTestCase.parseStatement(
         "void x = 0;",
         [
             ParserErrorCode.VOID_VARIABLE,
             ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE]);
   }
 
   void test_voidVariable_statement_noInitializer() {
     ParserTestCase.parseStatement(
@@ skipping 176 matching lines @@
         " + 2",
         "; } }");
   }
 
   void test_insert_period() {
     // "f() => a + b;"
     // "f() => a + b.;"
     _assertParse("f() => a + b", "", ".", ";");
   }
 
-  void test_insert_periodAndIdentifier() {
-    // "f() => a + b;"
-    // "f() => a + b.x;"
-    _assertParse("f() => a + b", "", ".x", ";");
-  }
-
   void test_insert_period_betweenIdentifiers1() {
     // "f() => a b;"
     // "f() => a. b;"
     _assertParse("f() => a", "", ".", " b;");
   }
 
   void test_insert_period_betweenIdentifiers2() {
     // "f() => a b;"
     // "f() => a .b;"
     _assertParse("f() => a ", "", ".", "b;");
   }
 
   void test_insert_period_betweenIdentifiers3() {
     // "f() => a  b;"
     // "f() => a . b;"
     _assertParse("f() => a ", "", ".", " b;");
   }
 
   void test_insert_period_insideExistingIdentifier() {
     // "f() => ab;"
     // "f() => a.b;"
     _assertParse("f() => a", "", ".", "b;");
   }
 
+  void test_insert_periodAndIdentifier() {
+    // "f() => a + b;"
+    // "f() => a + b.x;"
+    _assertParse("f() => a + b", "", ".x", ";");
+  }
+
   void test_insert_simpleToComplexExression() {
     // "/** An [A]. */ class A {} class B { m() => 1; }"
     // "/** An [A]. */ class A {} class B { m() => 1 + 2; }"
     _assertParse(
         "/** An [A]. */ class A {} class B { m() => 1",
         "",
         " + 2",
         "; }");
   }
 
@@ skipping 599 matching lines @@
   void test_additiveExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression(
         "super + +",
         [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is BinaryExpression,
         BinaryExpression,
         expression.leftOperand);
   }
 
-  void test_assignmentExpression_missing_LHS() {
-    AssignmentExpression expression =
-        ParserTestCase.parseExpression("= 0", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is SimpleIdentifier,
-        SimpleIdentifier,
-        expression.leftHandSide);
-    expect(expression.leftHandSide.isSynthetic, isTrue);
-  }
-
-  void test_assignmentExpression_missing_RHS() {
-    AssignmentExpression expression =
-        ParserTestCase.parseExpression("x =", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is SimpleIdentifier,
-        SimpleIdentifier,
-        expression.leftHandSide);
-    expect(expression.rightHandSide.isSynthetic, isTrue);
-  }
-
   void test_assignmentExpression_missing_compound1() {
     AssignmentExpression expression = ParserTestCase.parseExpression(
         "= y = 0",
         [ParserErrorCode.MISSING_IDENTIFIER]);
     Expression syntheticExpression = expression.leftHandSide;
     EngineTestCase.assertInstanceOf(
         (obj) => obj is SimpleIdentifier,
         SimpleIdentifier,
         syntheticExpression);
     expect(syntheticExpression.isSynthetic, isTrue);
@@ skipping 18 matching lines @@
         [ParserErrorCode.MISSING_IDENTIFIER]);
     Expression syntheticExpression =
         (expression.rightHandSide as AssignmentExpression).rightHandSide;
     EngineTestCase.assertInstanceOf(
         (obj) => obj is SimpleIdentifier,
         SimpleIdentifier,
         syntheticExpression);
     expect(syntheticExpression.isSynthetic, isTrue);
   }
 
+  void test_assignmentExpression_missing_LHS() {
+    AssignmentExpression expression =
+        ParserTestCase.parseExpression("= 0", [ParserErrorCode.MISSING_IDENTIFIER]);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is SimpleIdentifier,
+        SimpleIdentifier,
+        expression.leftHandSide);
+    expect(expression.leftHandSide.isSynthetic, isTrue);
+  }
+
+  void test_assignmentExpression_missing_RHS() {
+    AssignmentExpression expression =
+        ParserTestCase.parseExpression("x =", [ParserErrorCode.MISSING_IDENTIFIER]);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is SimpleIdentifier,
+        SimpleIdentifier,
+        expression.leftHandSide);
+    expect(expression.rightHandSide.isSynthetic, isTrue);
+  }
+
   void test_bitwiseAndExpression_missing_LHS() {
     BinaryExpression expression =
         ParserTestCase.parseExpression("& y", [ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is SimpleIdentifier,
         SimpleIdentifier,
         expression.leftOperand);
     expect(expression.leftOperand.isSynthetic, isTrue);
   }
 
@@ skipping 411 matching lines @@
     expect(vars, hasLength(1));
     expect(vars[0].name.name, "v");
   }
 
   void test_functionExpression_named() {
     ParserTestCase.parseExpression(
         "m(f() => 0);",
         [ParserErrorCode.EXPECTED_TOKEN]);
   }
 
-  void test_incompleteField_const() {
-    CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
-class C {
-  const
-}''', [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN]);
-    NodeList<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(1));
-    CompilationUnitMember unitMember = declarations[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ClassDeclaration,
-        ClassDeclaration,
-        unitMember);
-    NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
-    expect(members, hasLength(1));
-    ClassMember classMember = members[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FieldDeclaration,
-        FieldDeclaration,
-        classMember);
-    VariableDeclarationList fieldList =
-        (classMember as FieldDeclaration).fields;
-    expect((fieldList.keyword as KeywordToken).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 = ParserTestCase.parseCompilationUnit(r'''
-class C {
-  final
-}''', [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN]);
-    NodeList<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(1));
-    CompilationUnitMember unitMember = declarations[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ClassDeclaration,
-        ClassDeclaration,
-        unitMember);
-    NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
-    expect(members, hasLength(1));
-    ClassMember classMember = members[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FieldDeclaration,
-        FieldDeclaration,
-        classMember);
-    VariableDeclarationList fieldList =
-        (classMember as FieldDeclaration).fields;
-    expect((fieldList.keyword as KeywordToken).keyword, Keyword.FINAL);
-    NodeList<VariableDeclaration> fields = fieldList.variables;
-    expect(fields, hasLength(1));
-    VariableDeclaration field = fields[0];
-    expect(field.name.isSynthetic, isTrue);
-  }
-
-  void test_incompleteField_var() {
-    CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
-class C {
-  var
-}''', [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN]);
-    NodeList<CompilationUnitMember> declarations = unit.declarations;
-    expect(declarations, hasLength(1));
-    CompilationUnitMember unitMember = declarations[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ClassDeclaration,
-        ClassDeclaration,
-        unitMember);
-    NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
-    expect(members, hasLength(1));
-    ClassMember classMember = members[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FieldDeclaration,
-        FieldDeclaration,
-        classMember);
-    VariableDeclarationList fieldList =
-        (classMember as FieldDeclaration).fields;
-    expect((fieldList.keyword as KeywordToken).keyword, Keyword.VAR);
-    NodeList<VariableDeclaration> fields = fieldList.variables;
-    expect(fields, hasLength(1));
-    VariableDeclaration field = fields[0];
-    expect(field.name.isSynthetic, isTrue);
-  }
-
   void test_incomplete_conditionalExpression() {
     ParserTestCase.parseExpression(
         "x ? 0",
         [ParserErrorCode.EXPECTED_TOKEN, ParserErrorCode.MISSING_IDENTIFIER]);
   }
 
   void test_incomplete_constructorInitializers_empty() {
     ParserTestCase.parse3(
         "parseClassMember",
         ["C"],
@@ skipping 98 matching lines @@
         (obj) => obj is TopLevelVariableDeclaration,
         TopLevelVariableDeclaration,
         member);
     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 = ParserTestCase.parseCompilationUnit(r'''
+class C {
+  const
+}''', [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN]);
+    NodeList<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(1));
+    CompilationUnitMember unitMember = declarations[0];
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is ClassDeclaration,
+        ClassDeclaration,
+        unitMember);
+    NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
+    expect(members, hasLength(1));
+    ClassMember classMember = members[0];
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is FieldDeclaration,
+        FieldDeclaration,
+        classMember);
+    VariableDeclarationList fieldList =
+        (classMember as FieldDeclaration).fields;
+    expect((fieldList.keyword as KeywordToken).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 = ParserTestCase.parseCompilationUnit(r'''
+class C {
+  final
+}''', [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN]);
+    NodeList<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(1));
+    CompilationUnitMember unitMember = declarations[0];
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is ClassDeclaration,
+        ClassDeclaration,
+        unitMember);
+    NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
+    expect(members, hasLength(1));
+    ClassMember classMember = members[0];
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is FieldDeclaration,
+        FieldDeclaration,
+        classMember);
+    VariableDeclarationList fieldList =
+        (classMember as FieldDeclaration).fields;
+    expect((fieldList.keyword as KeywordToken).keyword, Keyword.FINAL);
+    NodeList<VariableDeclaration> fields = fieldList.variables;
+    expect(fields, hasLength(1));
+    VariableDeclaration field = fields[0];
+    expect(field.name.isSynthetic, isTrue);
+  }
+
+  void test_incompleteField_var() {
+    CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
+class C {
+  var
+}''', [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN]);
+    NodeList<CompilationUnitMember> declarations = unit.declarations;
+    expect(declarations, hasLength(1));
+    CompilationUnitMember unitMember = declarations[0];
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is ClassDeclaration,
+        ClassDeclaration,
+        unitMember);
+    NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
+    expect(members, hasLength(1));
+    ClassMember classMember = members[0];
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is FieldDeclaration,
+        FieldDeclaration,
+        classMember);
+    VariableDeclarationList fieldList =
+        (classMember as FieldDeclaration).fields;
+    expect((fieldList.keyword as KeywordToken).keyword, Keyword.VAR);
+    NodeList<VariableDeclaration> fields = fieldList.variables;
+    expect(fields, hasLength(1));
+    VariableDeclaration field = fields[0];
+    expect(field.name.isSynthetic, isTrue);
+  }
+
   void test_invalidFunctionBodyModifier() {
     ParserTestCase.parseCompilationUnit(
         "f() sync {}",
         [ParserErrorCode.MISSING_STAR_AFTER_SYNC]);
   }
 
   void test_isExpression_noType() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(
         "class Bar<T extends Foo> {m(x){if (x is ) return;if (x is !)}}",
         [
@@ skipping 141 matching lines @@
         [
             ParserErrorCode.MISSING_IDENTIFIER,
             ParserErrorCode.MISSING_IDENTIFIER,
             ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is BinaryExpression,
         BinaryExpression,
         expression.rightOperand);
   }
 
+  void test_missing_commaInArgumentList() {
+    ParserTestCase.parseExpression(
+        "f(x: 1 y: 2)",
+        [ParserErrorCode.EXPECTED_TOKEN]);
+  }
+
   void test_missingGet() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
 class C {
   int length {}
   void foo() {}
 }''', [ParserErrorCode.MISSING_GET]);
     expect(unit, isNotNull);
     ClassDeclaration classDeclaration =
         unit.declarations[0] as ClassDeclaration;
     NodeList<ClassMember> members = classDeclaration.members;
@@ skipping 15 matching lines @@
         "parseClassMember",
         <Object>["C"],
         "@override }",
         [ParserErrorCode.EXPECTED_CLASS_MEMBER]);
     expect(method.documentationComment, isNull);
     NodeList<Annotation> metadata = method.metadata;
     expect(metadata, hasLength(1));
     expect(metadata[0].name.name, "override");
   }
 
-  void test_missing_commaInArgumentList() {
-    ParserTestCase.parseExpression(
-        "f(x: 1 y: 2)",
-        [ParserErrorCode.EXPECTED_TOKEN]);
-  }
-
   void test_multiplicativeExpression_missing_LHS() {
     BinaryExpression expression =
         ParserTestCase.parseExpression("* y", [ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is SimpleIdentifier,
         SimpleIdentifier,
         expression.leftOperand);
     expect(expression.leftOperand.isSynthetic, isTrue);
   }
 
@@ skipping 688 matching lines @@
     PostfixExpression toNode = AstFactory.postfixExpression(
         AstFactory.identifier3(variableName),
         TokenType.PLUS_PLUS);
     ResolutionCopier.copyResolutionData(fromNode, toNode);
     expect(toNode.propagatedElement, same(propagatedElement));
     expect(toNode.propagatedType, same(propagatedType));
     expect(toNode.staticElement, same(staticElement));
     expect(toNode.staticType, same(staticType));
   }
 
+  void test_visitPrefixedIdentifier() {
+    PrefixedIdentifier fromNode = AstFactory.identifier5("p", "f");
+    DartType propagatedType = ElementFactory.classElement2("C").type;
+    fromNode.propagatedType = propagatedType;
+    DartType staticType = ElementFactory.classElement2("C").type;
+    fromNode.staticType = staticType;
+    PrefixedIdentifier toNode = AstFactory.identifier5("p", "f");
+    ResolutionCopier.copyResolutionData(fromNode, toNode);
+    expect(toNode.propagatedType, same(propagatedType));
+    expect(toNode.staticType, same(staticType));
+  }
+
   void test_visitPrefixExpression() {
     PrefixExpression fromNode =
         AstFactory.prefixExpression(TokenType.PLUS_PLUS, AstFactory.identifier3("x"));
     MethodElement propagatedElement =
         ElementFactory.methodElement("+", ElementFactory.classElement2("C").type);
     DartType propagatedType = ElementFactory.classElement2("C").type;
     fromNode.propagatedElement = propagatedElement;
     fromNode.propagatedType = propagatedType;
     DartType staticType = ElementFactory.classElement2("C").type;
     MethodElement staticElement =
         ElementFactory.methodElement("+", ElementFactory.classElement2("C").type);
     fromNode.staticElement = staticElement;
     fromNode.staticType = staticType;
     PrefixExpression toNode =
         AstFactory.prefixExpression(TokenType.PLUS_PLUS, AstFactory.identifier3("x"));
     ResolutionCopier.copyResolutionData(fromNode, toNode);
     expect(toNode.propagatedElement, same(propagatedElement));
     expect(toNode.propagatedType, same(propagatedType));
     expect(toNode.staticElement, same(staticElement));
     expect(toNode.staticType, same(staticType));
   }
 
-  void test_visitPrefixedIdentifier() {
-    PrefixedIdentifier fromNode = AstFactory.identifier5("p", "f");
-    DartType propagatedType = ElementFactory.classElement2("C").type;
-    fromNode.propagatedType = propagatedType;
-    DartType staticType = ElementFactory.classElement2("C").type;
-    fromNode.staticType = staticType;
-    PrefixedIdentifier toNode = AstFactory.identifier5("p", "f");
-    ResolutionCopier.copyResolutionData(fromNode, toNode);
-    expect(toNode.propagatedType, same(propagatedType));
-    expect(toNode.staticType, same(staticType));
-  }
-
   void test_visitPropertyAccess() {
     PropertyAccess fromNode =
         AstFactory.propertyAccess2(AstFactory.identifier3("x"), "y");
     DartType propagatedType = ElementFactory.classElement2("C").type;
     fromNode.propagatedType = propagatedType;
     DartType staticType = ElementFactory.classElement2("C").type;
     fromNode.staticType = staticType;
     PropertyAccess toNode =
         AstFactory.propertyAccess2(AstFactory.identifier3("x"), "y");
     ResolutionCopier.copyResolutionData(fromNode, toNode);
@@ skipping 193 matching lines @@
         ParserTestCase.parse("parseCommentReference", <Object>["this", 5], "");
     SimpleIdentifier identifier = EngineTestCase.assertInstanceOf(
         (obj) => obj is SimpleIdentifier,
         SimpleIdentifier,
         reference.identifier);
     expect(identifier.token, isNotNull);
     expect(identifier.name, "a");
     expect(identifier.offset, 5);
   }
 
-  void test_Parser() {
-    expect(new Parser(null, null), isNotNull);
-  }
-
   void test_computeStringValue_emptyInterpolationPrefix() {
     expect(_computeStringValue("'''", true, false), "");
   }
 
   void test_computeStringValue_escape_b() {
     expect(_computeStringValue("'\\b'", true, true), "\b");
   }
 
   void test_computeStringValue_escape_f() {
     expect(_computeStringValue("'\\f'", true, true), "\f");
@@ skipping 352 matching lines @@
   void test_parseAnnotation_n3_a() {
     Annotation annotation =
         ParserTestCase.parse4("parseAnnotation", "@A.B.C(x,y)");
     expect(annotation.atSign, isNotNull);
     expect(annotation.name, isNotNull);
     expect(annotation.period, isNotNull);
     expect(annotation.constructorName, isNotNull);
     expect(annotation.arguments, isNotNull);
   }
 
+  void test_parseArgument_named() {
+    NamedExpression expression = ParserTestCase.parse4("parseArgument", "n: x");
+    Label name = expression.name;
+    expect(name, isNotNull);
+    expect(name.label, isNotNull);
+    expect(name.colon, isNotNull);
+    expect(expression.expression, isNotNull);
+  }
+
+  void test_parseArgument_unnamed() {
+    String lexeme = "x";
+    SimpleIdentifier identifier =
+        ParserTestCase.parse4("parseArgument", lexeme);
+    expect(identifier.name, lexeme);
+  }
+
   void test_parseArgumentList_empty() {
     ArgumentList argumentList =
         ParserTestCase.parse4("parseArgumentList", "()");
     NodeList<Expression> arguments = argumentList.arguments;
     expect(arguments, hasLength(0));
   }
 
   void test_parseArgumentList_mixed() {
     ArgumentList argumentList =
         ParserTestCase.parse4("parseArgumentList", "(w, x, y: y, z: z)");
     NodeList<Expression> arguments = argumentList.arguments;
     expect(arguments, hasLength(4));
   }
 
   void test_parseArgumentList_noNamed() {
     ArgumentList argumentList =
         ParserTestCase.parse4("parseArgumentList", "(x, y, z)");
     NodeList<Expression> arguments = argumentList.arguments;
     expect(arguments, hasLength(3));
   }
 
   void test_parseArgumentList_onlyNamed() {
     ArgumentList argumentList =
         ParserTestCase.parse4("parseArgumentList", "(x: x, y: y)");
     NodeList<Expression> arguments = argumentList.arguments;
     expect(arguments, hasLength(2));
   }
 
-  void test_parseArgument_named() {
-    NamedExpression expression = ParserTestCase.parse4("parseArgument", "n: x");
-    Label name = expression.name;
-    expect(name, isNotNull);
-    expect(name.label, isNotNull);
-    expect(name.colon, isNotNull);
-    expect(expression.expression, isNotNull);
-  }
-
-  void test_parseArgument_unnamed() {
-    String lexeme = "x";
-    SimpleIdentifier identifier =
-        ParserTestCase.parse4("parseArgument", lexeme);
-    expect(identifier.name, lexeme);
-  }
-
   void test_parseAssertStatement() {
     AssertStatement statement =
         ParserTestCase.parse4("parseAssertStatement", "assert (x);");
-    expect(statement.keyword, isNotNull);
+    expect(statement.assertKeyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     expect(statement.condition, isNotNull);
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.semicolon, isNotNull);
   }
 
   void test_parseAssignableExpression_expression_args_dot() {
     PropertyAccess propertyAccess =
         ParserTestCase.parse("parseAssignableExpression", <Object>[false], "(x)(y).z");
     FunctionExpressionInvocation invocation =
@@ skipping 223 matching lines @@
   void test_parseBlock_nonEmpty() {
     Block block = ParserTestCase.parse4("parseBlock", "{;}");
     expect(block.leftBracket, isNotNull);
     expect(block.statements, hasLength(1));
     expect(block.rightBracket, isNotNull);
   }
 
   void test_parseBreakStatement_label() {
     BreakStatement statement =
         ParserTestCase.parse4("parseBreakStatement", "break foo;");
-    expect(statement.keyword, isNotNull);
+    expect(statement.breakKeyword, isNotNull);
     expect(statement.label, isNotNull);
     expect(statement.semicolon, isNotNull);
   }
 
   void test_parseBreakStatement_noLabel() {
     BreakStatement statement = ParserTestCase.parse4(
         "parseBreakStatement",
         "break;",
         [ParserErrorCode.BREAK_OUTSIDE_OF_LOOP]);
-    expect(statement.keyword, isNotNull);
+    expect(statement.breakKeyword, isNotNull);
     expect(statement.label, isNull);
     expect(statement.semicolon, isNotNull);
   }
 
   void test_parseCascadeSection_i() {
     IndexExpression section =
         ParserTestCase.parse4("parseCascadeSection", "..[i]");
     expect(section.target, isNull);
     expect(section.leftBracket, isNotNull);
     expect(section.index, isNotNull);
@@ skipping 223 matching lines @@
     expect(declaration.typeParameters, isNull);
   }
 
   void test_parseClassDeclaration_native() {
     ClassDeclaration declaration = ParserTestCase.parse(
         "parseClassDeclaration",
         <Object>[emptyCommentAndMetadata(), null],
         "class A native 'nativeValue' {}");
     NativeClause nativeClause = declaration.nativeClause;
     expect(nativeClause, isNotNull);
-    expect(nativeClause.keyword, isNotNull);
+    expect(nativeClause.nativeKeyword, isNotNull);
     expect(nativeClause.name.stringValue, "nativeValue");
-    expect(nativeClause.beginToken, same(nativeClause.keyword));
+    expect(nativeClause.beginToken, same(nativeClause.nativeKeyword));
     expect(nativeClause.endToken, same(nativeClause.name.endToken));
   }
 
   void test_parseClassDeclaration_nonEmpty() {
     ClassDeclaration declaration = ParserTestCase.parse(
         "parseClassDeclaration",
         <Object>[emptyCommentAndMetadata(), null],
         "class A {var f;}");
     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() {
     ClassTypeAlias typeAlias = ParserTestCase.parse(
         "parseClassDeclaration",
         <Object>[emptyCommentAndMetadata(), null],
         "class A = Object with B implements C;");
-    expect(typeAlias.keyword, isNotNull);
+    expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name, isNotNull);
     expect(typeAlias.typeParameters, isNull);
     expect(typeAlias.withClause, isNotNull);
     expect(typeAlias.implementsClause, isNotNull);
-    expect(typeAlias.implementsClause.keyword, isNotNull);
+    expect(typeAlias.implementsClause.implementsKeyword, isNotNull);
     expect(typeAlias.implementsClause.interfaces.length, 1);
     expect(typeAlias.semicolon, isNotNull);
   }
 
   void test_parseClassDeclaration_typeAlias_withB() {
     ClassTypeAlias typeAlias = ParserTestCase.parse(
         "parseClassDeclaration",
         <Object>[emptyCommentAndMetadata(), null],
         "class A = Object with B;");
-    expect(typeAlias.keyword, isNotNull);
+    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() {
@@ skipping 353 matching lines @@
     expect(constructor.body, isNotNull);
   }
 
   void test_parseClassTypeAlias_abstract() {
     Token classToken = TokenFactory.tokenFromKeyword(Keyword.CLASS);
     Token abstractToken = TokenFactory.tokenFromKeyword(Keyword.ABSTRACT);
     ClassTypeAlias classTypeAlias = ParserTestCase.parse(
         "parseClassTypeAlias",
         <Object>[emptyCommentAndMetadata(), abstractToken, classToken],
         "A = B with C;");
-    expect(classTypeAlias.keyword, isNotNull);
+    expect(classTypeAlias.typedefKeyword, isNotNull);
     expect(classTypeAlias.name.name, "A");
     expect(classTypeAlias.equals, isNotNull);
     expect(classTypeAlias.abstractKeyword, isNotNull);
     expect(classTypeAlias.superclass.name.name, isNotNull, reason: "B");
     expect(classTypeAlias.withClause, isNotNull);
     expect(classTypeAlias.implementsClause, isNull);
     expect(classTypeAlias.semicolon, isNotNull);
   }
 
   void test_parseClassTypeAlias_implements() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.CLASS);
     ClassTypeAlias classTypeAlias = ParserTestCase.parse(
         "parseClassTypeAlias",
         <Object>[emptyCommentAndMetadata(), null, token],
         "A = B with C implements D;");
-    expect(classTypeAlias.keyword, isNotNull);
+    expect(classTypeAlias.typedefKeyword, isNotNull);
     expect(classTypeAlias.name.name, "A");
     expect(classTypeAlias.equals, isNotNull);
     expect(classTypeAlias.abstractKeyword, isNull);
     expect(classTypeAlias.superclass.name.name, isNotNull, reason: "B");
     expect(classTypeAlias.withClause, isNotNull);
     expect(classTypeAlias.implementsClause, isNotNull);
     expect(classTypeAlias.semicolon, isNotNull);
   }
 
   void test_parseClassTypeAlias_with() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.CLASS);
     ClassTypeAlias classTypeAlias = ParserTestCase.parse(
         "parseClassTypeAlias",
         <Object>[emptyCommentAndMetadata(), null, token],
         "A = B with C;");
-    expect(classTypeAlias.keyword, isNotNull);
+    expect(classTypeAlias.typedefKeyword, isNotNull);
     expect(classTypeAlias.name.name, "A");
     expect(classTypeAlias.equals, isNotNull);
     expect(classTypeAlias.abstractKeyword, isNull);
     expect(classTypeAlias.superclass.name.name, isNotNull, reason: "B");
     expect(classTypeAlias.withClause, isNotNull);
     expect(classTypeAlias.implementsClause, isNull);
     expect(classTypeAlias.semicolon, isNotNull);
   }
 
   void test_parseClassTypeAlias_with_implements() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.CLASS);
     ClassTypeAlias classTypeAlias = ParserTestCase.parse(
         "parseClassTypeAlias",
         <Object>[emptyCommentAndMetadata(), null, token],
         "A = B with C implements D;");
-    expect(classTypeAlias.keyword, isNotNull);
+    expect(classTypeAlias.typedefKeyword, isNotNull);
     expect(classTypeAlias.name.name, "A");
     expect(classTypeAlias.equals, isNotNull);
     expect(classTypeAlias.abstractKeyword, isNull);
     expect(classTypeAlias.superclass.name.name, isNotNull, reason: "B");
     expect(classTypeAlias.withClause, isNotNull);
     expect(classTypeAlias.implementsClause, isNotNull);
     expect(classTypeAlias.semicolon, isNotNull);
   }
 
   void test_parseCombinator_hide() {
@@ skipping 358 matching lines @@
             3)];
     List<CommentReference> references =
         ParserTestCase.parse("parseCommentReferences", <Object>[tokens], "");
     expect(references, hasLength(1));
     CommentReference reference = references[0];
     expect(reference, isNotNull);
     expect(reference.identifier, isNotNull);
     expect(reference.offset, 15);
   }
 
+  void test_parseCompilationUnit_abstractAsPrefix_parameterized() {
+    CompilationUnit unit = ParserTestCase.parse4(
+        "parseCompilationUnit",
+        "abstract<dynamic> _abstract = new abstract.A();");
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(1));
+  }
+
+  void test_parseCompilationUnit_builtIn_asFunctionName() {
+    ParserTestCase.parse4("parseCompilationUnit", "abstract(x) => 0;");
+    ParserTestCase.parse4("parseCompilationUnit", "as(x) => 0;");
+    ParserTestCase.parse4("parseCompilationUnit", "dynamic(x) => 0;");
+    ParserTestCase.parse4("parseCompilationUnit", "export(x) => 0;");
+    ParserTestCase.parse4("parseCompilationUnit", "external(x) => 0;");
+    ParserTestCase.parse4("parseCompilationUnit", "factory(x) => 0;");
+    ParserTestCase.parse4("parseCompilationUnit", "get(x) => 0;");
+    ParserTestCase.parse4("parseCompilationUnit", "implements(x) => 0;");
+    ParserTestCase.parse4("parseCompilationUnit", "import(x) => 0;");
+    ParserTestCase.parse4("parseCompilationUnit", "library(x) => 0;");
+    ParserTestCase.parse4("parseCompilationUnit", "operator(x) => 0;");
+    ParserTestCase.parse4("parseCompilationUnit", "part(x) => 0;");
+    ParserTestCase.parse4("parseCompilationUnit", "set(x) => 0;");
+    ParserTestCase.parse4("parseCompilationUnit", "static(x) => 0;");
+    ParserTestCase.parse4("parseCompilationUnit", "typedef(x) => 0;");
+  }
+
+  void test_parseCompilationUnit_directives_multiple() {
+    CompilationUnit unit =
+        ParserTestCase.parse4("parseCompilationUnit", "library l;\npart 'a.dart';");
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(2));
+    expect(unit.declarations, hasLength(0));
+  }
+
+  void test_parseCompilationUnit_directives_single() {
+    CompilationUnit unit =
+        ParserTestCase.parse4("parseCompilationUnit", "library l;");
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(1));
+    expect(unit.declarations, hasLength(0));
+  }
+
+  void test_parseCompilationUnit_empty() {
+    CompilationUnit unit = ParserTestCase.parse4("parseCompilationUnit", "");
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(0));
+  }
+
+  void test_parseCompilationUnit_exportAsPrefix() {
+    CompilationUnit unit = ParserTestCase.parse4(
+        "parseCompilationUnit",
+        "export.A _export = new export.A();");
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(1));
+  }
+
+  void test_parseCompilationUnit_exportAsPrefix_parameterized() {
+    CompilationUnit unit = ParserTestCase.parse4(
+        "parseCompilationUnit",
+        "export<dynamic> _export = new export.A();");
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(1));
+  }
+
+  void test_parseCompilationUnit_operatorAsPrefix_parameterized() {
+    CompilationUnit unit = ParserTestCase.parse4(
+        "parseCompilationUnit",
+        "operator<dynamic> _operator = new operator.A();");
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(1));
+  }
+
+  void test_parseCompilationUnit_script() {
+    CompilationUnit unit =
+        ParserTestCase.parse4("parseCompilationUnit", "#! /bin/dart");
+    expect(unit.scriptTag, isNotNull);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(0));
+  }
+
+  void test_parseCompilationUnit_skipFunctionBody_withInterpolation() {
+    ParserTestCase.parseFunctionBodies = false;
+    CompilationUnit unit =
+        ParserTestCase.parse4("parseCompilationUnit", "f() { '\${n}'; }");
+    expect(unit.scriptTag, isNull);
+    expect(unit.declarations, hasLength(1));
+  }
+
+  void test_parseCompilationUnit_topLevelDeclaration() {
+    CompilationUnit unit =
+        ParserTestCase.parse4("parseCompilationUnit", "class A {}");
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(1));
+  }
+
+  void test_parseCompilationUnit_typedefAsPrefix() {
+    CompilationUnit unit = ParserTestCase.parse4(
+        "parseCompilationUnit",
+        "typedef.A _typedef = new typedef.A();");
+    expect(unit.scriptTag, isNull);
+    expect(unit.directives, hasLength(0));
+    expect(unit.declarations, hasLength(1));
+  }
+
   void test_parseCompilationUnitMember_abstractAsPrefix() {
     TopLevelVariableDeclaration declaration = ParserTestCase.parse(
         "parseCompilationUnitMember",
         <Object>[emptyCommentAndMetadata()],
         "abstract.A _abstract = new abstract.A();");
     expect(declaration.semicolon, isNotNull);
     expect(declaration.variables, isNotNull);
   }
 
   void test_parseCompilationUnitMember_class() {
@@ skipping 153 matching lines @@
     expect(declaration.functionExpression, isNotNull);
     expect(declaration.propertyKeyword, isNotNull);
     expect(declaration.returnType, isNotNull);
   }
 
   void test_parseCompilationUnitMember_typeAlias_abstract() {
     ClassTypeAlias typeAlias = ParserTestCase.parse(
         "parseCompilationUnitMember",
         <Object>[emptyCommentAndMetadata()],
         "abstract class C = S with M;");
-    expect(typeAlias.keyword, isNotNull);
+    expect(typeAlias.typedefKeyword, isNotNull);
     expect(typeAlias.name.name, "C");
     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() {
     ClassTypeAlias typeAlias = ParserTestCase.parse(
         "parseCompilationUnitMember",
         <Object>[emptyCommentAndMetadata()],
         "class C<E> = S<E> with M<E> implements I<E>;");
-    expect(typeAlias.keyword, isNotNull);
+    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() {
     ClassTypeAlias typeAlias = ParserTestCase.parse(
         "parseCompilationUnitMember",
         <Object>[emptyCommentAndMetadata()],
         "class C = S with M implements I;");
-    expect(typeAlias.keyword, isNotNull);
+    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() {
     ClassTypeAlias typeAlias = ParserTestCase.parse(
         "parseCompilationUnitMember",
         <Object>[emptyCommentAndMetadata()],
         "class C = S with M;");
-    expect(typeAlias.keyword, isNotNull);
+    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);
   }
 
@@ skipping 26 matching lines @@
 
   void test_parseCompilationUnitMember_variableSet() {
     TopLevelVariableDeclaration declaration = ParserTestCase.parse(
         "parseCompilationUnitMember",
         <Object>[emptyCommentAndMetadata()],
         "String set = null;");
     expect(declaration.semicolon, isNotNull);
     expect(declaration.variables, isNotNull);
   }
 
-  void test_parseCompilationUnit_abstractAsPrefix_parameterized() {
-    CompilationUnit unit = ParserTestCase.parse4(
-        "parseCompilationUnit",
-        "abstract<dynamic> _abstract = new abstract.A();");
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(0));
-    expect(unit.declarations, hasLength(1));
-  }
-
-  void test_parseCompilationUnit_builtIn_asFunctionName() {
-    ParserTestCase.parse4("parseCompilationUnit", "abstract(x) => 0;");
-    ParserTestCase.parse4("parseCompilationUnit", "as(x) => 0;");
-    ParserTestCase.parse4("parseCompilationUnit", "dynamic(x) => 0;");
-    ParserTestCase.parse4("parseCompilationUnit", "export(x) => 0;");
-    ParserTestCase.parse4("parseCompilationUnit", "external(x) => 0;");
-    ParserTestCase.parse4("parseCompilationUnit", "factory(x) => 0;");
-    ParserTestCase.parse4("parseCompilationUnit", "get(x) => 0;");
-    ParserTestCase.parse4("parseCompilationUnit", "implements(x) => 0;");
-    ParserTestCase.parse4("parseCompilationUnit", "import(x) => 0;");
-    ParserTestCase.parse4("parseCompilationUnit", "library(x) => 0;");
-    ParserTestCase.parse4("parseCompilationUnit", "operator(x) => 0;");
-    ParserTestCase.parse4("parseCompilationUnit", "part(x) => 0;");
-    ParserTestCase.parse4("parseCompilationUnit", "set(x) => 0;");
-    ParserTestCase.parse4("parseCompilationUnit", "static(x) => 0;");
-    ParserTestCase.parse4("parseCompilationUnit", "typedef(x) => 0;");
-  }
-
-  void test_parseCompilationUnit_directives_multiple() {
-    CompilationUnit unit =
-        ParserTestCase.parse4("parseCompilationUnit", "library l;\npart 'a.dart';");
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(2));
-    expect(unit.declarations, hasLength(0));
-  }
-
-  void test_parseCompilationUnit_directives_single() {
-    CompilationUnit unit =
-        ParserTestCase.parse4("parseCompilationUnit", "library l;");
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(1));
-    expect(unit.declarations, hasLength(0));
-  }
-
-  void test_parseCompilationUnit_empty() {
-    CompilationUnit unit = ParserTestCase.parse4("parseCompilationUnit", "");
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(0));
-    expect(unit.declarations, hasLength(0));
-  }
-
-  void test_parseCompilationUnit_exportAsPrefix() {
-    CompilationUnit unit = ParserTestCase.parse4(
-        "parseCompilationUnit",
-        "export.A _export = new export.A();");
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(0));
-    expect(unit.declarations, hasLength(1));
-  }
-
-  void test_parseCompilationUnit_exportAsPrefix_parameterized() {
-    CompilationUnit unit = ParserTestCase.parse4(
-        "parseCompilationUnit",
-        "export<dynamic> _export = new export.A();");
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(0));
-    expect(unit.declarations, hasLength(1));
-  }
-
-  void test_parseCompilationUnit_operatorAsPrefix_parameterized() {
-    CompilationUnit unit = ParserTestCase.parse4(
-        "parseCompilationUnit",
-        "operator<dynamic> _operator = new operator.A();");
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(0));
-    expect(unit.declarations, hasLength(1));
-  }
-
-  void test_parseCompilationUnit_script() {
-    CompilationUnit unit =
-        ParserTestCase.parse4("parseCompilationUnit", "#! /bin/dart");
-    expect(unit.scriptTag, isNotNull);
-    expect(unit.directives, hasLength(0));
-    expect(unit.declarations, hasLength(0));
-  }
-
-  void test_parseCompilationUnit_skipFunctionBody_withInterpolation() {
-    ParserTestCase.parseFunctionBodies = false;
-    CompilationUnit unit =
-        ParserTestCase.parse4("parseCompilationUnit", "f() { '\${n}'; }");
-    expect(unit.scriptTag, isNull);
-    expect(unit.declarations, hasLength(1));
-  }
-
-  void test_parseCompilationUnit_topLevelDeclaration() {
-    CompilationUnit unit =
-        ParserTestCase.parse4("parseCompilationUnit", "class A {}");
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(0));
-    expect(unit.declarations, hasLength(1));
-  }
-
-  void test_parseCompilationUnit_typedefAsPrefix() {
-    CompilationUnit unit = ParserTestCase.parse4(
-        "parseCompilationUnit",
-        "typedef.A _typedef = new typedef.A();");
-    expect(unit.scriptTag, isNull);
-    expect(unit.directives, hasLength(0));
-    expect(unit.declarations, hasLength(1));
-  }
-
   void test_parseConditionalExpression() {
     ConditionalExpression expression =
         ParserTestCase.parse4("parseConditionalExpression", "x ? y : z");
     expect(expression.condition, isNotNull);
     expect(expression.question, isNotNull);
     expect(expression.thenExpression, isNotNull);
     expect(expression.colon, isNotNull);
     expect(expression.elseExpression, isNotNull);
   }
 
@@ skipping 48 matching lines @@
   }
 
   void test_parseConstructor() {
     // TODO(brianwilkerson) Implement tests for this method.
 //    parse("parseConstructor", new Class[] {Parser.CommentAndMetadata.class,
 //        Token.class, Token.class, SimpleIdentifier.class, Token.class,
 //        SimpleIdentifier.class, FormalParameterList.class}, new Object[] {emptyCommentAndMetadata(),
 //        null, null, null, null, null, null}, "");
   }
 
+  void test_parseConstructor_with_pseudo_function_literal() {
+    // "(b) {}" should not be misinterpreted as a function literal even though
+    // it looks like one.
+    ClassMember classMember =
+        ParserTestCase.parse("parseClassMember", <Object>["C"], "C() : a = (b) {}");
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is ConstructorDeclaration,
+        ConstructorDeclaration,
+        classMember);
+    ConstructorDeclaration constructor = classMember as ConstructorDeclaration;
+    NodeList<ConstructorInitializer> initializers = constructor.initializers;
+    expect(initializers, hasLength(1));
+    ConstructorInitializer initializer = initializers[0];
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is ConstructorFieldInitializer,
+        ConstructorFieldInitializer,
+        initializer);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is ParenthesizedExpression,
+        ParenthesizedExpression,
+        (initializer as ConstructorFieldInitializer).expression);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is BlockFunctionBody,
+        BlockFunctionBody,
+        constructor.body);
+  }
+
   void test_parseConstructorFieldInitializer_qualified() {
     ConstructorFieldInitializer invocation =
         ParserTestCase.parse4("parseConstructorFieldInitializer", "this.a = b");
     expect(invocation.equals, isNotNull);
     expect(invocation.expression, isNotNull);
     expect(invocation.fieldName, isNotNull);
-    expect(invocation.keyword, isNotNull);
+    expect(invocation.thisKeyword, isNotNull);
     expect(invocation.period, isNotNull);
   }
 
   void test_parseConstructorFieldInitializer_unqualified() {
     ConstructorFieldInitializer invocation =
         ParserTestCase.parse4("parseConstructorFieldInitializer", "a = b");
     expect(invocation.equals, isNotNull);
     expect(invocation.expression, isNotNull);
     expect(invocation.fieldName, isNotNull);
-    expect(invocation.keyword, isNull);
+    expect(invocation.thisKeyword, isNull);
     expect(invocation.period, isNull);
   }
 
   void test_parseConstructorName_named_noPrefix() {
     ConstructorName name =
         ParserTestCase.parse4("parseConstructorName", "A.n;");
     expect(name.type, isNotNull);
     expect(name.period, isNull);
     expect(name.name, isNull);
   }
@@ skipping 14 matching lines @@
   }
 
   void test_parseConstructorName_unnamed_prefixed() {
     ConstructorName name =
         ParserTestCase.parse4("parseConstructorName", "p.A;");
     expect(name.type, isNotNull);
     expect(name.period, isNull);
     expect(name.name, isNull);
   }
 
-  void test_parseConstructor_with_pseudo_function_literal() {
-    // "(b) {}" should not be misinterpreted as a function literal even though
-    // it looks like one.
-    ClassMember classMember =
-        ParserTestCase.parse("parseClassMember", <Object>["C"], "C() : a = (b) {}");
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ConstructorDeclaration,
-        ConstructorDeclaration,
-        classMember);
-    ConstructorDeclaration constructor = classMember as ConstructorDeclaration;
-    NodeList<ConstructorInitializer> initializers = constructor.initializers;
-    expect(initializers, hasLength(1));
-    ConstructorInitializer initializer = initializers[0];
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ConstructorFieldInitializer,
-        ConstructorFieldInitializer,
-        initializer);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ParenthesizedExpression,
-        ParenthesizedExpression,
-        (initializer as ConstructorFieldInitializer).expression);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is BlockFunctionBody,
-        BlockFunctionBody,
-        constructor.body);
-  }
-
   void test_parseContinueStatement_label() {
     ContinueStatement statement = ParserTestCase.parse4(
         "parseContinueStatement",
         "continue foo;",
         [ParserErrorCode.CONTINUE_OUTSIDE_OF_LOOP]);
-    expect(statement.keyword, isNotNull);
+    expect(statement.continueKeyword, isNotNull);
     expect(statement.label, isNotNull);
     expect(statement.semicolon, isNotNull);
   }
 
   void test_parseContinueStatement_noLabel() {
     ContinueStatement statement = ParserTestCase.parse4(
         "parseContinueStatement",
         "continue;",
         [ParserErrorCode.CONTINUE_OUTSIDE_OF_LOOP]);
-    expect(statement.keyword, isNotNull);
+    expect(statement.continueKeyword, isNotNull);
     expect(statement.label, isNull);
     expect(statement.semicolon, isNotNull);
   }
 
   void test_parseDirective_export() {
     ExportDirective directive = ParserTestCase.parse(
         "parseDirective",
         <Object>[emptyCommentAndMetadata()],
         "export 'lib/lib.dart';");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.combinators, hasLength(0));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseDirective_import() {
     ImportDirective directive = ParserTestCase.parse(
         "parseDirective",
         <Object>[emptyCommentAndMetadata()],
         "import 'lib/lib.dart';");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
-    expect(directive.asToken, isNull);
+    expect(directive.asKeyword, isNull);
     expect(directive.prefix, isNull);
     expect(directive.combinators, hasLength(0));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseDirective_library() {
     LibraryDirective directive = ParserTestCase.parse(
         "parseDirective",
         <Object>[emptyCommentAndMetadata()],
         "library l;");
-    expect(directive.libraryToken, isNotNull);
+    expect(directive.libraryKeyword, isNotNull);
     expect(directive.name, isNotNull);
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseDirective_part() {
     PartDirective directive = ParserTestCase.parse(
         "parseDirective",
         <Object>[emptyCommentAndMetadata()],
         "part 'lib/lib.dart';");
-    expect(directive.partToken, isNotNull);
+    expect(directive.partKeyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseDirective_partOf() {
     PartOfDirective directive = ParserTestCase.parse(
         "parseDirective",
         <Object>[emptyCommentAndMetadata()],
         "part of l;");
-    expect(directive.partToken, isNotNull);
-    expect(directive.ofToken, isNotNull);
+    expect(directive.partKeyword, isNotNull);
+    expect(directive.ofKeyword, isNotNull);
     expect(directive.libraryName, isNotNull);
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseDirectives_complete() {
     CompilationUnit unit =
         _parseDirectives("#! /bin/dart\nlibrary l;\nclass A {}");
     expect(unit.scriptTag, isNotNull);
     expect(unit.directives, hasLength(1));
   }
@@ skipping 28 matching lines @@
     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_parseDoStatement() {
-    DoStatement statement =
-        ParserTestCase.parse4("parseDoStatement", "do {} while (x);");
-    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_parseDocumentationComment_block() {
     Comment comment =
         ParserTestCase.parse4("parseDocumentationComment", "/** */ class");
     expect(comment.isBlock, isFalse);
     expect(comment.isDocumentation, isTrue);
     expect(comment.isEndOfLine, isFalse);
   }
 
   void test_parseDocumentationComment_block_withReference() {
     Comment comment =
         ParserTestCase.parse4("parseDocumentationComment", "/** [a] */ class");
     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() {
     Comment comment =
         ParserTestCase.parse4("parseDocumentationComment", "/// \n/// \n class");
     expect(comment.isBlock, isFalse);
     expect(comment.isDocumentation, isTrue);
     expect(comment.isEndOfLine, isFalse);
   }
 
+  void test_parseDoStatement() {
+    DoStatement statement =
+        ParserTestCase.parse4("parseDoStatement", "do {} while (x);");
+    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_parseEmptyStatement() {
     EmptyStatement statement =
         ParserTestCase.parse4("parseEmptyStatement", ";");
     expect(statement.semicolon, isNotNull);
   }
 
   void test_parseEnumDeclaration_one() {
     EnumDeclaration declaration = ParserTestCase.parse(
         "parseEnumDeclaration",
         <Object>[emptyCommentAndMetadata()],
         "enum E {ONE}");
     expect(declaration.documentationComment, isNull);
-    expect(declaration.keyword, isNotNull);
+    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() {
     EnumDeclaration declaration = ParserTestCase.parse(
         "parseEnumDeclaration",
         <Object>[emptyCommentAndMetadata()],
         "enum E {ONE,}");
     expect(declaration.documentationComment, isNull);
-    expect(declaration.keyword, isNotNull);
+    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() {
     EnumDeclaration declaration = ParserTestCase.parse(
         "parseEnumDeclaration",
         <Object>[emptyCommentAndMetadata()],
         "enum E {ONE, TWO}");
     expect(declaration.documentationComment, isNull);
-    expect(declaration.keyword, isNotNull);
+    expect(declaration.enumKeyword, isNotNull);
     expect(declaration.leftBracket, isNotNull);
     expect(declaration.name, isNotNull);
     expect(declaration.constants, hasLength(2));
     expect(declaration.rightBracket, isNotNull);
   }
 
   void test_parseEqualityExpression_normal() {
     BinaryExpression expression =
         ParserTestCase.parse4("parseEqualityExpression", "x == y");
     expect(expression.leftOperand, isNotNull);
@@ skipping 62 matching lines @@
     ExportDirective directive = ParserTestCase.parse(
         "parseExportDirective",
         <Object>[emptyCommentAndMetadata()],
         "export 'lib/lib.dart' show B hide A;");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.combinators, hasLength(2));
     expect(directive.semicolon, isNotNull);
   }
 
-  void test_parseExpressionList_multiple() {
-    List<Expression> result =
-        ParserTestCase.parse4("parseExpressionList", "1, 2, 3");
-    expect(result, hasLength(3));
-  }
-
-  void test_parseExpressionList_single() {
-    List<Expression> result = ParserTestCase.parse4("parseExpressionList", "1");
-    expect(result, hasLength(1));
-  }
-
-  void test_parseExpressionWithoutCascade_assign() {
-    // TODO(brianwilkerson) Implement more tests for this method.
-    AssignmentExpression expression =
-        ParserTestCase.parse4("parseExpressionWithoutCascade", "x = y");
-    expect(expression.leftHandSide, isNotNull);
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.EQ);
-    expect(expression.rightHandSide, isNotNull);
-  }
-
-  void test_parseExpressionWithoutCascade_comparison() {
-    BinaryExpression expression =
-        ParserTestCase.parse4("parseExpressionWithoutCascade", "--a.b == c");
-    expect(expression.leftOperand, isNotNull);
-    expect(expression.operator, isNotNull);
-    expect(expression.operator.type, TokenType.EQ_EQ);
-    expect(expression.rightOperand, isNotNull);
-  }
-
-  void test_parseExpressionWithoutCascade_superMethodInvocation() {
-    MethodInvocation invocation =
-        ParserTestCase.parse4("parseExpressionWithoutCascade", "super.m()");
-    expect(invocation.target, isNotNull);
-    expect(invocation.methodName, isNotNull);
-    expect(invocation.argumentList, isNotNull);
-  }
-
   void test_parseExpression_assign() {
     // TODO(brianwilkerson) Implement more tests for this method.
     AssignmentExpression expression =
         ParserTestCase.parse4("parseExpression", "x = y");
     expect(expression.leftHandSide, isNotNull);
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.EQ);
     expect(expression.rightHandSide, isNotNull);
   }
 
@@ skipping 62 matching lines @@
   }
 
   void test_parseExpression_superMethodInvocation() {
     MethodInvocation invocation =
         ParserTestCase.parse4("parseExpression", "super.m()");
     expect(invocation.target, isNotNull);
     expect(invocation.methodName, isNotNull);
     expect(invocation.argumentList, isNotNull);
   }
 
+  void test_parseExpressionList_multiple() {
+    List<Expression> result =
+        ParserTestCase.parse4("parseExpressionList", "1, 2, 3");
+    expect(result, hasLength(3));
+  }
+
+  void test_parseExpressionList_single() {
+    List<Expression> result = ParserTestCase.parse4("parseExpressionList", "1");
+    expect(result, hasLength(1));
+  }
+
+  void test_parseExpressionWithoutCascade_assign() {
+    // TODO(brianwilkerson) Implement more tests for this method.
+    AssignmentExpression expression =
+        ParserTestCase.parse4("parseExpressionWithoutCascade", "x = y");
+    expect(expression.leftHandSide, isNotNull);
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.EQ);
+    expect(expression.rightHandSide, isNotNull);
+  }
+
+  void test_parseExpressionWithoutCascade_comparison() {
+    BinaryExpression expression =
+        ParserTestCase.parse4("parseExpressionWithoutCascade", "--a.b == c");
+    expect(expression.leftOperand, isNotNull);
+    expect(expression.operator, isNotNull);
+    expect(expression.operator.type, TokenType.EQ_EQ);
+    expect(expression.rightOperand, isNotNull);
+  }
+
+  void test_parseExpressionWithoutCascade_superMethodInvocation() {
+    MethodInvocation invocation =
+        ParserTestCase.parse4("parseExpressionWithoutCascade", "super.m()");
+    expect(invocation.target, isNotNull);
+    expect(invocation.methodName, isNotNull);
+    expect(invocation.argumentList, isNotNull);
+  }
+
   void test_parseExtendsClause() {
     ExtendsClause clause =
         ParserTestCase.parse4("parseExtendsClause", "extends B");
-    expect(clause.keyword, isNotNull);
+    expect(clause.extendsKeyword, isNotNull);
     expect(clause.superclass, isNotNull);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is TypeName,
         TypeName,
         clause.superclass);
   }
 
   void test_parseFinalConstVarOrType_const_noType() {
     FinalConstVarOrType result =
         ParserTestCase.parse("parseFinalConstVarOrType", <Object>[false], "const");
@@ skipping 53 matching lines @@
     expect(result.type, isNotNull);
   }
 
   void test_parseFinalConstVarOrType_type_prefixed() {
     FinalConstVarOrType result =
         ParserTestCase.parse("parseFinalConstVarOrType", <Object>[false], "p.A a");
     expect(result.keyword, isNull);
     expect(result.type, isNotNull);
   }
 
+  void test_parseFinalConstVarOrType_type_prefixed_noIdentifier() {
+    FinalConstVarOrType result =
+        ParserTestCase.parse("parseFinalConstVarOrType", <Object>[false], "p.A,");
+    expect(result.keyword, isNull);
+    expect(result.type, isNotNull);
+  }
+
   void test_parseFinalConstVarOrType_type_prefixedAndParameterized() {
     FinalConstVarOrType result =
         ParserTestCase.parse("parseFinalConstVarOrType", <Object>[false], "p.A<B> a");
     expect(result.keyword, isNull);
     expect(result.type, isNotNull);
   }
-
-  void test_parseFinalConstVarOrType_type_prefixed_noIdentifier() {
-    FinalConstVarOrType result =
-        ParserTestCase.parse("parseFinalConstVarOrType", <Object>[false], "p.A,");
-    expect(result.keyword, isNull);
-    expect(result.type, isNotNull);
-  }
 
   void test_parseFinalConstVarOrType_type_simple() {
     FinalConstVarOrType result =
         ParserTestCase.parse("parseFinalConstVarOrType", <Object>[false], "A a");
     expect(result.keyword, isNull);
     expect(result.type, isNotNull);
   }
 
   void test_parseFinalConstVarOrType_var() {
     FinalConstVarOrType result =
@@ skipping 12 matching lines @@
     expect(result.type, isNotNull);
   }
 
   void test_parseFinalConstVarOrType_void_noIdentifier() {
     FinalConstVarOrType result =
         ParserTestCase.parse("parseFinalConstVarOrType", <Object>[false], "void,");
     expect(result.keyword, isNull);
     expect(result.type, isNotNull);
   }
 
+  void test_parseFormalParameter_final_withType_named() {
+    ParameterKind kind = ParameterKind.NAMED;
+    DefaultFormalParameter parameter = ParserTestCase.parse(
+        "parseFormalParameter",
+        <Object>[kind],
+        "final A a : null");
+    SimpleFormalParameter simpleParameter =
+        parameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.kind, kind);
+    expect(parameter.separator, isNotNull);
+    expect(parameter.defaultValue, isNotNull);
+    expect(parameter.kind, kind);
+  }
+
+  void test_parseFormalParameter_final_withType_normal() {
+    ParameterKind kind = ParameterKind.REQUIRED;
+    SimpleFormalParameter parameter =
+        ParserTestCase.parse("parseFormalParameter", <Object>[kind], "final A a");
+    expect(parameter.identifier, isNotNull);
+    expect(parameter.keyword, isNotNull);
+    expect(parameter.type, isNotNull);
+    expect(parameter.kind, kind);
+  }
+
+  void test_parseFormalParameter_final_withType_positional() {
+    ParameterKind kind = ParameterKind.POSITIONAL;
+    DefaultFormalParameter parameter = ParserTestCase.parse(
+        "parseFormalParameter",
+        <Object>[kind],
+        "final A a = null");
+    SimpleFormalParameter simpleParameter =
+        parameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.kind, kind);
+    expect(parameter.separator, isNotNull);
+    expect(parameter.defaultValue, isNotNull);
+    expect(parameter.kind, kind);
+  }
+
+  void test_parseFormalParameter_nonFinal_withType_named() {
+    ParameterKind kind = ParameterKind.NAMED;
+    DefaultFormalParameter parameter =
+        ParserTestCase.parse("parseFormalParameter", <Object>[kind], "A a : null");
+    SimpleFormalParameter simpleParameter =
+        parameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.kind, kind);
+    expect(parameter.separator, isNotNull);
+    expect(parameter.defaultValue, isNotNull);
+    expect(parameter.kind, kind);
+  }
+
+  void test_parseFormalParameter_nonFinal_withType_normal() {
+    ParameterKind kind = ParameterKind.REQUIRED;
+    SimpleFormalParameter parameter =
+        ParserTestCase.parse("parseFormalParameter", <Object>[kind], "A a");
+    expect(parameter.identifier, isNotNull);
+    expect(parameter.keyword, isNull);
+    expect(parameter.type, isNotNull);
+    expect(parameter.kind, kind);
+  }
+
+  void test_parseFormalParameter_nonFinal_withType_positional() {
+    ParameterKind kind = ParameterKind.POSITIONAL;
+    DefaultFormalParameter parameter =
+        ParserTestCase.parse("parseFormalParameter", <Object>[kind], "A a = null");
+    SimpleFormalParameter simpleParameter =
+        parameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNull);
+    expect(simpleParameter.type, isNotNull);
+    expect(simpleParameter.kind, kind);
+    expect(parameter.separator, isNotNull);
+    expect(parameter.defaultValue, isNotNull);
+    expect(parameter.kind, kind);
+  }
+
+  void test_parseFormalParameter_var() {
+    ParameterKind kind = ParameterKind.REQUIRED;
+    SimpleFormalParameter parameter =
+        ParserTestCase.parse("parseFormalParameter", <Object>[kind], "var a");
+    expect(parameter.identifier, isNotNull);
+    expect(parameter.keyword, isNotNull);
+    expect(parameter.type, isNull);
+    expect(parameter.kind, kind);
+  }
+
+  void test_parseFormalParameter_var_named() {
+    ParameterKind kind = ParameterKind.NAMED;
+    DefaultFormalParameter parameter =
+        ParserTestCase.parse("parseFormalParameter", <Object>[kind], "var a : null");
+    SimpleFormalParameter simpleParameter =
+        parameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.kind, kind);
+    expect(parameter.separator, isNotNull);
+    expect(parameter.defaultValue, isNotNull);
+    expect(parameter.kind, kind);
+  }
+
+  void test_parseFormalParameter_var_positional() {
+    ParameterKind kind = ParameterKind.POSITIONAL;
+    DefaultFormalParameter parameter =
+        ParserTestCase.parse("parseFormalParameter", <Object>[kind], "var a = null");
+    SimpleFormalParameter simpleParameter =
+        parameter.parameter as SimpleFormalParameter;
+    expect(simpleParameter.identifier, isNotNull);
+    expect(simpleParameter.keyword, isNotNull);
+    expect(simpleParameter.type, isNull);
+    expect(simpleParameter.kind, kind);
+    expect(parameter.separator, isNotNull);
+    expect(parameter.defaultValue, isNotNull);
+    expect(parameter.kind, kind);
+  }
+
+  void test_parseFormalParameterList_empty() {
+    FormalParameterList parameterList =
+        ParserTestCase.parse4("parseFormalParameterList", "()");
+    expect(parameterList.leftParenthesis, isNotNull);
+    expect(parameterList.leftDelimiter, isNull);
+    expect(parameterList.parameters, hasLength(0));
+    expect(parameterList.rightDelimiter, isNull);
+    expect(parameterList.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_named_multiple() {
+    FormalParameterList parameterList =
+        ParserTestCase.parse4("parseFormalParameterList", "({A a : 1, B b, C c : 3})");
+    expect(parameterList.leftParenthesis, isNotNull);
+    expect(parameterList.leftDelimiter, isNotNull);
+    expect(parameterList.parameters, hasLength(3));
+    expect(parameterList.rightDelimiter, isNotNull);
+    expect(parameterList.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_named_single() {
+    FormalParameterList parameterList =
+        ParserTestCase.parse4("parseFormalParameterList", "({A a})");
+    expect(parameterList.leftParenthesis, isNotNull);
+    expect(parameterList.leftDelimiter, isNotNull);
+    expect(parameterList.parameters, hasLength(1));
+    expect(parameterList.rightDelimiter, isNotNull);
+    expect(parameterList.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_normal_multiple() {
+    FormalParameterList parameterList =
+        ParserTestCase.parse4("parseFormalParameterList", "(A a, B b, C c)");
+    expect(parameterList.leftParenthesis, isNotNull);
+    expect(parameterList.leftDelimiter, isNull);
+    expect(parameterList.parameters, hasLength(3));
+    expect(parameterList.rightDelimiter, isNull);
+    expect(parameterList.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_normal_named() {
+    FormalParameterList parameterList =
+        ParserTestCase.parse4("parseFormalParameterList", "(A a, {B b})");
+    expect(parameterList.leftParenthesis, isNotNull);
+    expect(parameterList.leftDelimiter, isNotNull);
+    expect(parameterList.parameters, hasLength(2));
+    expect(parameterList.rightDelimiter, isNotNull);
+    expect(parameterList.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_normal_positional() {
+    FormalParameterList parameterList =
+        ParserTestCase.parse4("parseFormalParameterList", "(A a, [B b])");
+    expect(parameterList.leftParenthesis, isNotNull);
+    expect(parameterList.leftDelimiter, isNotNull);
+    expect(parameterList.parameters, hasLength(2));
+    expect(parameterList.rightDelimiter, isNotNull);
+    expect(parameterList.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_normal_single() {
+    FormalParameterList parameterList =
+        ParserTestCase.parse4("parseFormalParameterList", "(A a)");
+    expect(parameterList.leftParenthesis, isNotNull);
+    expect(parameterList.leftDelimiter, isNull);
+    expect(parameterList.parameters, hasLength(1));
+    expect(parameterList.rightDelimiter, isNull);
+    expect(parameterList.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_positional_multiple() {
+    FormalParameterList parameterList = ParserTestCase.parse4(
+        "parseFormalParameterList",
+        "([A a = null, B b, C c = null])");
+    expect(parameterList.leftParenthesis, isNotNull);
+    expect(parameterList.leftDelimiter, isNotNull);
+    expect(parameterList.parameters, hasLength(3));
+    expect(parameterList.rightDelimiter, isNotNull);
+    expect(parameterList.rightParenthesis, isNotNull);
+  }
+
+  void test_parseFormalParameterList_positional_single() {
+    FormalParameterList parameterList =
+        ParserTestCase.parse4("parseFormalParameterList", "([A a = null])");
+    expect(parameterList.leftParenthesis, isNotNull);
+    expect(parameterList.leftDelimiter, isNotNull);
+    expect(parameterList.parameters, hasLength(1));
+    expect(parameterList.rightDelimiter, isNotNull);
+    expect(parameterList.rightParenthesis, isNotNull);
+  }
+
   void test_parseForStatement_each_await() {
     ForEachStatement statement =
         ParserTestCase.parse4("parseForStatement", "await for (element in list) {}");
     expect(statement.awaitKeyword, isNotNull);
     expect(statement.forKeyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     expect(statement.loopVariable, isNull);
     expect(statement.identifier, isNotNull);
     expect(statement.inKeyword, isNotNull);
     expect(statement.iterable, isNotNull);
@@ skipping 217 matching lines @@
     expect(statement.variables, isNull);
     expect(statement.initialization, isNull);
     expect(statement.leftSeparator, isNotNull);
     expect(statement.condition, isNull);
     expect(statement.rightSeparator, isNotNull);
     expect(statement.updaters, hasLength(1));
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.body, isNotNull);
   }
 
-  void test_parseFormalParameterList_empty() {
-    FormalParameterList parameterList =
-        ParserTestCase.parse4("parseFormalParameterList", "()");
-    expect(parameterList.leftParenthesis, isNotNull);
-    expect(parameterList.leftDelimiter, isNull);
-    expect(parameterList.parameters, hasLength(0));
-    expect(parameterList.rightDelimiter, isNull);
-    expect(parameterList.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_named_multiple() {
-    FormalParameterList parameterList =
-        ParserTestCase.parse4("parseFormalParameterList", "({A a : 1, B b, C c : 3})");
-    expect(parameterList.leftParenthesis, isNotNull);
-    expect(parameterList.leftDelimiter, isNotNull);
-    expect(parameterList.parameters, hasLength(3));
-    expect(parameterList.rightDelimiter, isNotNull);
-    expect(parameterList.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_named_single() {
-    FormalParameterList parameterList =
-        ParserTestCase.parse4("parseFormalParameterList", "({A a})");
-    expect(parameterList.leftParenthesis, isNotNull);
-    expect(parameterList.leftDelimiter, isNotNull);
-    expect(parameterList.parameters, hasLength(1));
-    expect(parameterList.rightDelimiter, isNotNull);
-    expect(parameterList.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_normal_multiple() {
-    FormalParameterList parameterList =
-        ParserTestCase.parse4("parseFormalParameterList", "(A a, B b, C c)");
-    expect(parameterList.leftParenthesis, isNotNull);
-    expect(parameterList.leftDelimiter, isNull);
-    expect(parameterList.parameters, hasLength(3));
-    expect(parameterList.rightDelimiter, isNull);
-    expect(parameterList.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_normal_named() {
-    FormalParameterList parameterList =
-        ParserTestCase.parse4("parseFormalParameterList", "(A a, {B b})");
-    expect(parameterList.leftParenthesis, isNotNull);
-    expect(parameterList.leftDelimiter, isNotNull);
-    expect(parameterList.parameters, hasLength(2));
-    expect(parameterList.rightDelimiter, isNotNull);
-    expect(parameterList.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_normal_positional() {
-    FormalParameterList parameterList =
-        ParserTestCase.parse4("parseFormalParameterList", "(A a, [B b])");
-    expect(parameterList.leftParenthesis, isNotNull);
-    expect(parameterList.leftDelimiter, isNotNull);
-    expect(parameterList.parameters, hasLength(2));
-    expect(parameterList.rightDelimiter, isNotNull);
-    expect(parameterList.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_normal_single() {
-    FormalParameterList parameterList =
-        ParserTestCase.parse4("parseFormalParameterList", "(A a)");
-    expect(parameterList.leftParenthesis, isNotNull);
-    expect(parameterList.leftDelimiter, isNull);
-    expect(parameterList.parameters, hasLength(1));
-    expect(parameterList.rightDelimiter, isNull);
-    expect(parameterList.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_positional_multiple() {
-    FormalParameterList parameterList = ParserTestCase.parse4(
-        "parseFormalParameterList",
-        "([A a = null, B b, C c = null])");
-    expect(parameterList.leftParenthesis, isNotNull);
-    expect(parameterList.leftDelimiter, isNotNull);
-    expect(parameterList.parameters, hasLength(3));
-    expect(parameterList.rightDelimiter, isNotNull);
-    expect(parameterList.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameterList_positional_single() {
-    FormalParameterList parameterList =
-        ParserTestCase.parse4("parseFormalParameterList", "([A a = null])");
-    expect(parameterList.leftParenthesis, isNotNull);
-    expect(parameterList.leftDelimiter, isNotNull);
-    expect(parameterList.parameters, hasLength(1));
-    expect(parameterList.rightDelimiter, isNotNull);
-    expect(parameterList.rightParenthesis, isNotNull);
-  }
-
-  void test_parseFormalParameter_final_withType_named() {
-    ParameterKind kind = ParameterKind.NAMED;
-    DefaultFormalParameter parameter = ParserTestCase.parse(
-        "parseFormalParameter",
-        <Object>[kind],
-        "final A a : null");
-    SimpleFormalParameter simpleParameter =
-        parameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.kind, kind);
-    expect(parameter.separator, isNotNull);
-    expect(parameter.defaultValue, isNotNull);
-    expect(parameter.kind, kind);
-  }
-
-  void test_parseFormalParameter_final_withType_normal() {
-    ParameterKind kind = ParameterKind.REQUIRED;
-    SimpleFormalParameter parameter =
-        ParserTestCase.parse("parseFormalParameter", <Object>[kind], "final A a");
-    expect(parameter.identifier, isNotNull);
-    expect(parameter.keyword, isNotNull);
-    expect(parameter.type, isNotNull);
-    expect(parameter.kind, kind);
-  }
-
-  void test_parseFormalParameter_final_withType_positional() {
-    ParameterKind kind = ParameterKind.POSITIONAL;
-    DefaultFormalParameter parameter = ParserTestCase.parse(
-        "parseFormalParameter",
-        <Object>[kind],
-        "final A a = null");
-    SimpleFormalParameter simpleParameter =
-        parameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.kind, kind);
-    expect(parameter.separator, isNotNull);
-    expect(parameter.defaultValue, isNotNull);
-    expect(parameter.kind, kind);
-  }
-
-  void test_parseFormalParameter_nonFinal_withType_named() {
-    ParameterKind kind = ParameterKind.NAMED;
-    DefaultFormalParameter parameter =
-        ParserTestCase.parse("parseFormalParameter", <Object>[kind], "A a : null");
-    SimpleFormalParameter simpleParameter =
-        parameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.kind, kind);
-    expect(parameter.separator, isNotNull);
-    expect(parameter.defaultValue, isNotNull);
-    expect(parameter.kind, kind);
-  }
-
-  void test_parseFormalParameter_nonFinal_withType_normal() {
-    ParameterKind kind = ParameterKind.REQUIRED;
-    SimpleFormalParameter parameter =
-        ParserTestCase.parse("parseFormalParameter", <Object>[kind], "A a");
-    expect(parameter.identifier, isNotNull);
-    expect(parameter.keyword, isNull);
-    expect(parameter.type, isNotNull);
-    expect(parameter.kind, kind);
-  }
-
-  void test_parseFormalParameter_nonFinal_withType_positional() {
-    ParameterKind kind = ParameterKind.POSITIONAL;
-    DefaultFormalParameter parameter =
-        ParserTestCase.parse("parseFormalParameter", <Object>[kind], "A a = null");
-    SimpleFormalParameter simpleParameter =
-        parameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNull);
-    expect(simpleParameter.type, isNotNull);
-    expect(simpleParameter.kind, kind);
-    expect(parameter.separator, isNotNull);
-    expect(parameter.defaultValue, isNotNull);
-    expect(parameter.kind, kind);
-  }
-
-  void test_parseFormalParameter_var() {
-    ParameterKind kind = ParameterKind.REQUIRED;
-    SimpleFormalParameter parameter =
-        ParserTestCase.parse("parseFormalParameter", <Object>[kind], "var a");
-    expect(parameter.identifier, isNotNull);
-    expect(parameter.keyword, isNotNull);
-    expect(parameter.type, isNull);
-    expect(parameter.kind, kind);
-  }
-
-  void test_parseFormalParameter_var_named() {
-    ParameterKind kind = ParameterKind.NAMED;
-    DefaultFormalParameter parameter =
-        ParserTestCase.parse("parseFormalParameter", <Object>[kind], "var a : null");
-    SimpleFormalParameter simpleParameter =
-        parameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.kind, kind);
-    expect(parameter.separator, isNotNull);
-    expect(parameter.defaultValue, isNotNull);
-    expect(parameter.kind, kind);
-  }
-
-  void test_parseFormalParameter_var_positional() {
-    ParameterKind kind = ParameterKind.POSITIONAL;
-    DefaultFormalParameter parameter =
-        ParserTestCase.parse("parseFormalParameter", <Object>[kind], "var a = null");
-    SimpleFormalParameter simpleParameter =
-        parameter.parameter as SimpleFormalParameter;
-    expect(simpleParameter.identifier, isNotNull);
-    expect(simpleParameter.keyword, isNotNull);
-    expect(simpleParameter.type, isNull);
-    expect(simpleParameter.kind, kind);
-    expect(parameter.separator, isNotNull);
-    expect(parameter.defaultValue, isNotNull);
-    expect(parameter.kind, kind);
-  }
-
   void test_parseFunctionBody_block() {
     BlockFunctionBody functionBody =
         ParserTestCase.parse("parseFunctionBody", <Object>[false, null, false], "{}");
     expect(functionBody.keyword, isNull);
     expect(functionBody.star, isNull);
     expect(functionBody.block, isNotNull);
     expect(functionBody.isAsynchronous, isFalse);
     expect(functionBody.isGenerator, isFalse);
     expect(functionBody.isSynchronous, isTrue);
   }
@@ skipping 73 matching lines @@
     expect(functionBody.isAsynchronous, isTrue);
     expect(functionBody.isGenerator, isFalse);
     expect(functionBody.isSynchronous, isFalse);
   }
 
   void test_parseFunctionBody_nativeFunctionBody() {
     NativeFunctionBody functionBody = ParserTestCase.parse(
         "parseFunctionBody",
         <Object>[false, null, false],
         "native 'str';");
-    expect(functionBody.nativeToken, isNotNull);
+    expect(functionBody.nativeKeyword, isNotNull);
     expect(functionBody.stringLiteral, isNotNull);
     expect(functionBody.semicolon, isNotNull);
   }
 
   void test_parseFunctionBody_skip_block() {
     ParserTestCase.parseFunctionBodies = false;
     FunctionBody functionBody =
         ParserTestCase.parse("parseFunctionBody", <Object>[false, null, false], "{}");
     EngineTestCase.assertInstanceOf(
         (obj) => obj is EmptyFunctionBody,
@@ skipping 31 matching lines @@
     FunctionBody functionBody = ParserTestCase.parse(
         "parseFunctionBody",
         <Object>[false, null, false],
         "=> y;");
     EngineTestCase.assertInstanceOf(
         (obj) => obj is EmptyFunctionBody,
         EmptyFunctionBody,
         functionBody);
   }
 
-  void test_parseFunctionDeclarationStatement() {
-    FunctionDeclarationStatement statement = ParserTestCase.parse4(
-        "parseFunctionDeclarationStatement",
-        "void f(int p) => p * 2;");
-    expect(statement.functionDeclaration, isNotNull);
-  }
-
   void test_parseFunctionDeclaration_function() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     TypeName returnType = new TypeName(new SimpleIdentifier(null), null);
     FunctionDeclaration declaration = ParserTestCase.parse(
         "parseFunctionDeclaration",
         <Object>[commentAndMetadata(comment), null, returnType],
         "f() {}");
     expect(declaration.documentationComment, comment);
     expect(declaration.returnType, returnType);
     expect(declaration.name, isNotNull);
@@ skipping 31 matching lines @@
     expect(declaration.documentationComment, comment);
     expect(declaration.returnType, returnType);
     expect(declaration.name, isNotNull);
     FunctionExpression expression = declaration.functionExpression;
     expect(expression, isNotNull);
     expect(expression.body, isNotNull);
     expect(expression.parameters, isNotNull);
     expect(declaration.propertyKeyword, isNotNull);
   }
 
+  void test_parseFunctionDeclarationStatement() {
+    FunctionDeclarationStatement statement = ParserTestCase.parse4(
+        "parseFunctionDeclarationStatement",
+        "void f(int p) => p * 2;");
+    expect(statement.functionDeclaration, isNotNull);
+  }
+
   void test_parseFunctionExpression_body_inExpression() {
     FunctionExpression expression =
         ParserTestCase.parse4("parseFunctionExpression", "(int i) => i++");
     expect(expression.body, isNotNull);
     expect(expression.parameters, isNotNull);
     expect((expression.body as ExpressionFunctionBody).semicolon, isNull);
   }
 
   void test_parseGetter_nonStatic() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
@@ skipping 89 matching lines @@
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.thenStatement, isNotNull);
     expect(statement.elseKeyword, isNull);
     expect(statement.elseStatement, isNull);
   }
 
   void test_parseImplementsClause_multiple() {
     ImplementsClause clause =
         ParserTestCase.parse4("parseImplementsClause", "implements A, B, C");
     expect(clause.interfaces, hasLength(3));
-    expect(clause.keyword, isNotNull);
+    expect(clause.implementsKeyword, isNotNull);
   }
 
   void test_parseImplementsClause_single() {
     ImplementsClause clause =
         ParserTestCase.parse4("parseImplementsClause", "implements A");
     expect(clause.interfaces, hasLength(1));
-    expect(clause.keyword, isNotNull);
+    expect(clause.implementsKeyword, isNotNull);
   }
 
   void test_parseImportDirective_deferred() {
     ImportDirective directive = ParserTestCase.parse(
         "parseImportDirective",
         <Object>[emptyCommentAndMetadata()],
         "import 'lib/lib.dart' deferred as a;");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
-    expect(directive.deferredToken, isNotNull);
-    expect(directive.asToken, 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() {
     ImportDirective directive = ParserTestCase.parse(
         "parseImportDirective",
         <Object>[emptyCommentAndMetadata()],
         "import 'lib/lib.dart' hide A, B;");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
-    expect(directive.deferredToken, isNull);
-    expect(directive.asToken, isNull);
+    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() {
     ImportDirective directive = ParserTestCase.parse(
         "parseImportDirective",
         <Object>[emptyCommentAndMetadata()],
         "import 'lib/lib.dart';");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
-    expect(directive.deferredToken, isNull);
-    expect(directive.asToken, isNull);
+    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() {
     ImportDirective directive = ParserTestCase.parse(
         "parseImportDirective",
         <Object>[emptyCommentAndMetadata()],
         "import 'lib/lib.dart' as a;");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
-    expect(directive.deferredToken, isNull);
-    expect(directive.asToken, 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() {
     ImportDirective directive = ParserTestCase.parse(
         "parseImportDirective",
         <Object>[emptyCommentAndMetadata()],
         "import 'lib/lib.dart' as a hide A show B;");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
-    expect(directive.deferredToken, isNull);
-    expect(directive.asToken, 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() {
     ImportDirective directive = ParserTestCase.parse(
         "parseImportDirective",
         <Object>[emptyCommentAndMetadata()],
         "import 'lib/lib.dart' as a show B hide A;");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
-    expect(directive.deferredToken, isNull);
-    expect(directive.asToken, 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() {
     ImportDirective directive = ParserTestCase.parse(
         "parseImportDirective",
         <Object>[emptyCommentAndMetadata()],
         "import 'lib/lib.dart' show A, B;");
     expect(directive.keyword, isNotNull);
     expect(directive.uri, isNotNull);
-    expect(directive.deferredToken, isNull);
-    expect(directive.asToken, isNull);
+    expect(directive.deferredKeyword, isNull);
+    expect(directive.asKeyword, isNull);
     expect(directive.prefix, isNull);
     expect(directive.combinators, hasLength(1));
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseInitializedIdentifierList_type() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     Token staticKeyword = TokenFactory.tokenFromKeyword(Keyword.STATIC);
     TypeName type = new TypeName(new SimpleIdentifier(null), null);
     FieldDeclaration declaration = ParserTestCase.parse(
@@ skipping 86 matching lines @@
     expect(name.period, isNotNull);
     expect(name.name, isNotNull);
     expect(expression.argumentList, isNotNull);
   }
 
   void test_parseLibraryDirective() {
     LibraryDirective directive = ParserTestCase.parse(
         "parseLibraryDirective",
         <Object>[emptyCommentAndMetadata()],
         "library l;");
-    expect(directive.libraryToken, isNotNull);
+    expect(directive.libraryKeyword, isNotNull);
     expect(directive.name, isNotNull);
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parseLibraryIdentifier_multiple() {
     String name = "a.b.c";
     LibraryIdentifier identifier =
         ParserTestCase.parse4("parseLibraryIdentifier", name);
     expect(identifier.name, name);
   }
@@ skipping 120 matching lines @@
 
   void test_parseLogicalOrExpression() {
     BinaryExpression expression =
         ParserTestCase.parse4("parseLogicalOrExpression", "x || y");
     expect(expression.leftOperand, isNotNull);
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.BAR_BAR);
     expect(expression.rightOperand, isNotNull);
   }
 
-  void test_parseMapLiteralEntry_complex() {
-    MapLiteralEntry entry =
-        ParserTestCase.parse4("parseMapLiteralEntry", "2 + 2 : y");
-    expect(entry.key, isNotNull);
-    expect(entry.separator, isNotNull);
-    expect(entry.value, isNotNull);
-  }
-
-  void test_parseMapLiteralEntry_int() {
-    MapLiteralEntry entry =
-        ParserTestCase.parse4("parseMapLiteralEntry", "0 : y");
-    expect(entry.key, isNotNull);
-    expect(entry.separator, isNotNull);
-    expect(entry.value, isNotNull);
-  }
-
-  void test_parseMapLiteralEntry_string() {
-    MapLiteralEntry entry =
-        ParserTestCase.parse4("parseMapLiteralEntry", "'x' : y");
-    expect(entry.key, isNotNull);
-    expect(entry.separator, isNotNull);
-    expect(entry.value, isNotNull);
-  }
-
   void test_parseMapLiteral_empty() {
     Token token = TokenFactory.tokenFromKeyword(Keyword.CONST);
     TypeArgumentList typeArguments = AstFactory.typeArgumentList(
         [AstFactory.typeName4("String"), AstFactory.typeName4("int")]);
     MapLiteral literal =
         ParserTestCase.parse("parseMapLiteral", <Object>[token, typeArguments], "{}");
     expect(literal.constKeyword, token);
     expect(literal.typeArguments, typeArguments);
     expect(literal.leftBracket, isNotNull);
     expect(literal.entries, hasLength(0));
@@ skipping 11 matching lines @@
   }
 
   void test_parseMapLiteral_single() {
     MapLiteral literal =
         ParserTestCase.parse("parseMapLiteral", <Object>[null, null], "{'x' : y}");
     expect(literal.leftBracket, isNotNull);
     expect(literal.entries, hasLength(1));
     expect(literal.rightBracket, isNotNull);
   }
 
+  void test_parseMapLiteralEntry_complex() {
+    MapLiteralEntry entry =
+        ParserTestCase.parse4("parseMapLiteralEntry", "2 + 2 : y");
+    expect(entry.key, isNotNull);
+    expect(entry.separator, isNotNull);
+    expect(entry.value, isNotNull);
+  }
+
+  void test_parseMapLiteralEntry_int() {
+    MapLiteralEntry entry =
+        ParserTestCase.parse4("parseMapLiteralEntry", "0 : y");
+    expect(entry.key, isNotNull);
+    expect(entry.separator, isNotNull);
+    expect(entry.value, isNotNull);
+  }
+
+  void test_parseMapLiteralEntry_string() {
+    MapLiteralEntry entry =
+        ParserTestCase.parse4("parseMapLiteralEntry", "'x' : y");
+    expect(entry.key, isNotNull);
+    expect(entry.separator, isNotNull);
+    expect(entry.value, isNotNull);
+  }
+
   void test_parseModifiers_abstract() {
     Modifiers modifiers = ParserTestCase.parse4("parseModifiers", "abstract A");
     expect(modifiers.abstractKeyword, isNotNull);
   }
 
   void test_parseModifiers_const() {
     Modifiers modifiers = ParserTestCase.parse4("parseModifiers", "const A");
     expect(modifiers.constKeyword, isNotNull);
   }
 
@@ skipping 344 matching lines @@
 
   void test_parseOptionalReturnType() {
     // TODO(brianwilkerson) Implement tests for this method.
   }
 
   void test_parsePartDirective_part() {
     PartDirective directive = ParserTestCase.parse(
         "parsePartDirective",
         <Object>[emptyCommentAndMetadata()],
         "part 'lib/lib.dart';");
-    expect(directive.partToken, isNotNull);
+    expect(directive.partKeyword, isNotNull);
     expect(directive.uri, isNotNull);
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parsePartDirective_partOf() {
     PartOfDirective directive = ParserTestCase.parse(
         "parsePartDirective",
         <Object>[emptyCommentAndMetadata()],
         "part of l;");
-    expect(directive.partToken, isNotNull);
-    expect(directive.ofToken, isNotNull);
+    expect(directive.partKeyword, isNotNull);
+    expect(directive.ofKeyword, isNotNull);
     expect(directive.libraryName, isNotNull);
     expect(directive.semicolon, isNotNull);
   }
 
   void test_parsePostfixExpression_decrement() {
     PostfixExpression expression =
         ParserTestCase.parse4("parsePostfixExpression", "i--");
     expect(expression.operand, isNotNull);
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.MINUS_MINUS);
@@ skipping 180 matching lines @@
         ParserTestCase.parse4("parsePrimaryExpression", "super.x");
     expect(propertyAccess.target is SuperExpression, isTrue);
     expect(propertyAccess.operator, isNotNull);
     expect(propertyAccess.operator.type, TokenType.PERIOD);
     expect(propertyAccess.propertyName, isNotNull);
   }
 
   void test_parsePrimaryExpression_this() {
     ThisExpression expression =
         ParserTestCase.parse4("parsePrimaryExpression", "this");
-    expect(expression.keyword, isNotNull);
+    expect(expression.thisKeyword, isNotNull);
   }
 
   void test_parsePrimaryExpression_true() {
     BooleanLiteral literal =
         ParserTestCase.parse4("parsePrimaryExpression", "true");
     expect(literal.literal, isNotNull);
     expect(literal.value, isTrue);
   }
 
+  void test_Parser() {
+    expect(new Parser(null, null), isNotNull);
+  }
+
   void test_parseRedirectingConstructorInvocation_named() {
     RedirectingConstructorInvocation invocation =
         ParserTestCase.parse4("parseRedirectingConstructorInvocation", "this.a()");
     expect(invocation.argumentList, isNotNull);
     expect(invocation.constructorName, isNotNull);
-    expect(invocation.keyword, isNotNull);
+    expect(invocation.thisKeyword, isNotNull);
     expect(invocation.period, isNotNull);
   }
 
   void test_parseRedirectingConstructorInvocation_unnamed() {
     RedirectingConstructorInvocation invocation =
         ParserTestCase.parse4("parseRedirectingConstructorInvocation", "this()");
     expect(invocation.argumentList, isNotNull);
     expect(invocation.constructorName, isNull);
-    expect(invocation.keyword, isNotNull);
+    expect(invocation.thisKeyword, isNotNull);
     expect(invocation.period, isNull);
   }
 
   void test_parseRelationalExpression_as() {
     AsExpression expression =
         ParserTestCase.parse4("parseRelationalExpression", "x as Y");
     expect(expression.expression, isNotNull);
     expect(expression.asOperator, isNotNull);
     expect(expression.type, isNotNull);
   }
@@ skipping 30 matching lines @@
         ParserTestCase.parse4("parseRelationalExpression", "super < y");
     expect(expression.leftOperand, isNotNull);
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.LT);
     expect(expression.rightOperand, isNotNull);
   }
 
   void test_parseRethrowExpression() {
     RethrowExpression expression =
         ParserTestCase.parse4("parseRethrowExpression", "rethrow;");
-    expect(expression.keyword, isNotNull);
+    expect(expression.rethrowKeyword, isNotNull);
   }
 
   void test_parseReturnStatement_noValue() {
     ReturnStatement statement =
         ParserTestCase.parse4("parseReturnStatement", "return;");
-    expect(statement.keyword, isNotNull);
+    expect(statement.returnKeyword, isNotNull);
     expect(statement.expression, isNull);
     expect(statement.semicolon, isNotNull);
   }
 
   void test_parseReturnStatement_value() {
     ReturnStatement statement =
         ParserTestCase.parse4("parseReturnStatement", "return x;");
-    expect(statement.keyword, isNotNull);
+    expect(statement.returnKeyword, isNotNull);
     expect(statement.expression, isNotNull);
     expect(statement.semicolon, isNotNull);
   }
 
   void test_parseReturnType_nonVoid() {
     TypeName typeName = ParserTestCase.parse4("parseReturnType", "A<B>");
     expect(typeName.name, isNotNull);
     expect(typeName.typeArguments, isNotNull);
   }
 
@@ skipping 142 matching lines @@
         ParserTestCase.parse4("parseStringLiteral", "'a'");
     expect(literal.literal, isNotNull);
     expect(literal.value, "a");
   }
 
   void test_parseSuperConstructorInvocation_named() {
     SuperConstructorInvocation invocation =
         ParserTestCase.parse4("parseSuperConstructorInvocation", "super.a()");
     expect(invocation.argumentList, isNotNull);
     expect(invocation.constructorName, isNotNull);
-    expect(invocation.keyword, isNotNull);
+    expect(invocation.superKeyword, isNotNull);
     expect(invocation.period, isNotNull);
   }
 
   void test_parseSuperConstructorInvocation_unnamed() {
     SuperConstructorInvocation invocation =
         ParserTestCase.parse4("parseSuperConstructorInvocation", "super()");
     expect(invocation.argumentList, isNotNull);
     expect(invocation.constructorName, isNull);
-    expect(invocation.keyword, isNotNull);
+    expect(invocation.superKeyword, isNotNull);
     expect(invocation.period, isNull);
   }
 
   void test_parseSwitchStatement_case() {
     SwitchStatement statement = ParserTestCase.parse4(
         "parseSwitchStatement",
         "switch (a) {case 1: return 'I';}");
-    expect(statement.keyword, isNotNull);
+    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() {
     SwitchStatement statement =
         ParserTestCase.parse4("parseSwitchStatement", "switch (a) {}");
-    expect(statement.keyword, isNotNull);
+    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() {
     SwitchStatement statement = ParserTestCase.parse4(
         "parseSwitchStatement",
         "switch (a) {l1: l2: l3: case(1):}");
-    expect(statement.keyword, isNotNull);
+    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].labels, hasLength(3));
     expect(statement.rightBracket, isNotNull);
   }
 
   void test_parseSwitchStatement_labeledStatementInCase() {
     SwitchStatement statement = ParserTestCase.parse4(
         "parseSwitchStatement",
         "switch (a) {case 0: f(); l1: g(); break;}");
-    expect(statement.keyword, isNotNull);
+    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_parseSymbolLiteral_builtInIdentifier() {
@@ skipping 39 matching lines @@
         ParserTestCase.parse4("parseSymbolLiteral", "#void");
     expect(literal.poundSign, isNotNull);
     List<Token> components = literal.components;
     expect(components, hasLength(1));
     expect(components[0].lexeme, "void");
   }
 
   void test_parseThrowExpression() {
     ThrowExpression expression =
         ParserTestCase.parse4("parseThrowExpression", "throw x;");
-    expect(expression.keyword, isNotNull);
+    expect(expression.throwKeyword, isNotNull);
     expect(expression.expression, isNotNull);
   }
 
   void test_parseThrowExpressionWithoutCascade() {
     ThrowExpression expression =
         ParserTestCase.parse4("parseThrowExpressionWithoutCascade", "throw x;");
-    expect(expression.keyword, isNotNull);
+    expect(expression.throwKeyword, isNotNull);
     expect(expression.expression, isNotNull);
   }
 
   void test_parseTryStatement_catch() {
     TryStatement statement =
         ParserTestCase.parse4("parseTryStatement", "try {} catch (e) {}");
     expect(statement.tryKeyword, isNotNull);
     expect(statement.body, isNotNull);
     NodeList<CatchClause> catchClauses = statement.catchClauses;
     expect(catchClauses, hasLength(1));
@@ skipping 106 matching lines @@
     expect(clause.body, isNotNull);
     expect(statement.finallyKeyword, isNotNull);
     expect(statement.finallyBlock, isNotNull);
   }
 
   void test_parseTypeAlias_function_noParameters() {
     FunctionTypeAlias typeAlias = ParserTestCase.parse(
         "parseTypeAlias",
         <Object>[emptyCommentAndMetadata()],
         "typedef bool F();");
-    expect(typeAlias.keyword, isNotNull);
+    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() {
     FunctionTypeAlias typeAlias = ParserTestCase.parse(
         "parseTypeAlias",
         <Object>[emptyCommentAndMetadata()],
         "typedef F();");
-    expect(typeAlias.keyword, isNotNull);
+    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() {
     FunctionTypeAlias typeAlias = ParserTestCase.parse(
         "parseTypeAlias",
         <Object>[emptyCommentAndMetadata()],
         "typedef A<B> F();");
-    expect(typeAlias.keyword, isNotNull);
+    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() {
     FunctionTypeAlias typeAlias = ParserTestCase.parse(
         "parseTypeAlias",
         <Object>[emptyCommentAndMetadata()],
         "typedef bool F(Object value);");
-    expect(typeAlias.keyword, isNotNull);
+    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() {
     FunctionTypeAlias typeAlias = ParserTestCase.parse(
         "parseTypeAlias",
         <Object>[emptyCommentAndMetadata()],
         "typedef bool F<E>();");
-    expect(typeAlias.keyword, isNotNull);
+    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() {
     FunctionTypeAlias typeAlias = ParserTestCase.parse(
         "parseTypeAlias",
         <Object>[emptyCommentAndMetadata()],
         "typedef void F();");
-    expect(typeAlias.keyword, isNotNull);
+    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_parseTypeArgumentList_multiple() {
     TypeArgumentList argumentList =
         ParserTestCase.parse4("parseTypeArgumentList", "<int, int, int>");
@@ skipping 73 matching lines @@
     expect(typeName.name, isNotNull);
     expect(typeName.typeArguments, isNotNull);
   }
 
   void test_parseTypeName_simple() {
     TypeName typeName = ParserTestCase.parse4("parseTypeName", "int");
     expect(typeName.name, isNotNull);
     expect(typeName.typeArguments, isNull);
   }
 
+  void test_parseTypeParameter_bounded() {
+    TypeParameter parameter =
+        ParserTestCase.parse4("parseTypeParameter", "A extends B");
+    expect(parameter.bound, isNotNull);
+    expect(parameter.extendsKeyword, isNotNull);
+    expect(parameter.name, isNotNull);
+  }
+
+  void test_parseTypeParameter_simple() {
+    TypeParameter parameter = ParserTestCase.parse4("parseTypeParameter", "A");
+    expect(parameter.bound, isNull);
+    expect(parameter.extendsKeyword, isNull);
+    expect(parameter.name, isNotNull);
+  }
+
   void test_parseTypeParameterList_multiple() {
     TypeParameterList parameterList =
         ParserTestCase.parse4("parseTypeParameterList", "<A, B extends C, D>");
     expect(parameterList.leftBracket, isNotNull);
     expect(parameterList.rightBracket, isNotNull);
     expect(parameterList.typeParameters, hasLength(3));
   }
 
   void test_parseTypeParameterList_parameterizedWithTrailingEquals() {
     TypeParameterList parameterList =
@@ skipping 12 matching lines @@
   }
 
   void test_parseTypeParameterList_withTrailingEquals() {
     TypeParameterList parameterList =
         ParserTestCase.parse4("parseTypeParameterList", "<A>=");
     expect(parameterList.leftBracket, isNotNull);
     expect(parameterList.rightBracket, isNotNull);
     expect(parameterList.typeParameters, hasLength(1));
   }
 
-  void test_parseTypeParameter_bounded() {
-    TypeParameter parameter =
-        ParserTestCase.parse4("parseTypeParameter", "A extends B");
-    expect(parameter.bound, isNotNull);
-    expect(parameter.keyword, isNotNull);
-    expect(parameter.name, isNotNull);
-  }
-
-  void test_parseTypeParameter_simple() {
-    TypeParameter parameter = ParserTestCase.parse4("parseTypeParameter", "A");
-    expect(parameter.bound, isNull);
-    expect(parameter.keyword, isNull);
-    expect(parameter.name, isNotNull);
-  }
-
   void test_parseUnaryExpression_decrement_normal() {
     PrefixExpression expression =
         ParserTestCase.parse4("parseUnaryExpression", "--x");
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.MINUS_MINUS);
     expect(expression.operand, isNotNull);
   }
 
   void test_parseUnaryExpression_decrement_super() {
     PrefixExpression expression =
@@ skipping 106 matching lines @@
   }
 
   void test_parseUnaryExpression_tilda_super() {
     PrefixExpression expression =
         ParserTestCase.parse4("parseUnaryExpression", "~super");
     expect(expression.operator, isNotNull);
     expect(expression.operator.type, TokenType.TILDE);
     expect(expression.operand, isNotNull);
   }
 
+  void test_parseVariableDeclaration_equals() {
+    VariableDeclaration declaration =
+        ParserTestCase.parse4("parseVariableDeclaration", "a = b");
+    expect(declaration.name, isNotNull);
+    expect(declaration.equals, isNotNull);
+    expect(declaration.initializer, isNotNull);
+  }
+
+  void test_parseVariableDeclaration_noEquals() {
+    VariableDeclaration declaration =
+        ParserTestCase.parse4("parseVariableDeclaration", "a");
+    expect(declaration.name, isNotNull);
+    expect(declaration.equals, isNull);
+    expect(declaration.initializer, isNull);
+  }
+
   void test_parseVariableDeclarationListAfterMetadata_const_noType() {
     VariableDeclarationList declarationList = ParserTestCase.parse(
         "parseVariableDeclarationListAfterMetadata",
         <Object>[emptyCommentAndMetadata()],
         "const a");
     expect(declarationList.keyword, isNotNull);
     expect(declarationList.type, isNull);
     expect(declarationList.variables, hasLength(1));
   }
 
@@ skipping 104 matching lines @@
     VariableDeclarationStatement statement = ParserTestCase.parse(
         "parseVariableDeclarationStatementAfterMetadata",
         <Object>[emptyCommentAndMetadata()],
         "var x;");
     expect(statement.semicolon, isNotNull);
     VariableDeclarationList variableList = statement.variables;
     expect(variableList, isNotNull);
     expect(variableList.variables, hasLength(1));
   }
 
-  void test_parseVariableDeclaration_equals() {
-    VariableDeclaration declaration =
-        ParserTestCase.parse4("parseVariableDeclaration", "a = b");
-    expect(declaration.name, isNotNull);
-    expect(declaration.equals, isNotNull);
-    expect(declaration.initializer, isNotNull);
-  }
-
-  void test_parseVariableDeclaration_noEquals() {
-    VariableDeclaration declaration =
-        ParserTestCase.parse4("parseVariableDeclaration", "a");
-    expect(declaration.name, isNotNull);
-    expect(declaration.equals, isNull);
-    expect(declaration.initializer, isNull);
-  }
-
   void test_parseWhileStatement() {
     WhileStatement statement =
         ParserTestCase.parse4("parseWhileStatement", "while (x) {}");
-    expect(statement.keyword, isNotNull);
+    expect(statement.whileKeyword, isNotNull);
     expect(statement.leftParenthesis, isNotNull);
     expect(statement.condition, isNotNull);
     expect(statement.rightParenthesis, isNotNull);
     expect(statement.body, isNotNull);
   }
 
   void test_parseWithClause_multiple() {
     WithClause clause =
         ParserTestCase.parse4("parseWithClause", "with A, B, C");
     expect(clause.withKeyword, isNotNull);
@@ skipping 305 matching lines @@
     // Parse the source.
     //
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(
         parser,
         methodName,
         <Object>[tokenStream],
         tokenStream) as Token;
   }
 }