New Analysis Engine snapshot.

pkg/analyzer_experimental/test/generated/parser_test.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.parser_test;
 
 import 'dart:collection';
 import 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_engine.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/source.dart';
 import 'package:analyzer_experimental/src/generated/error.dart';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
 import 'package:analyzer_experimental/src/generated/ast.dart';
 import 'package:analyzer_experimental/src/generated/parser.dart';
 import 'package:analyzer_experimental/src/generated/utilities_dart.dart';
 import 'package:unittest/unittest.dart' as _ut;
 import 'test_support.dart';
 import 'scanner_test.dart' show TokenFactory;
 
 /**
  * The class {@code SimpleParserTest} defines parser tests that test individual parsing method. The
  * code fragments should be as minimal as possible in order to test the method, but should not test
  * the interactions between the method under test and other methods.
  * <p>
  * More complex tests should be defined in the class {@link ComplexParserTest}.
  */
 class SimpleParserTest extends ParserTestCase {
   void fail_parseCommentReference_this() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["this", 5], "");
-    SimpleIdentifier identifier19 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
-    JUnitTestCase.assertNotNull(identifier19.token);
-    JUnitTestCase.assertEquals("a", identifier19.name);
-    JUnitTestCase.assertEquals(5, identifier19.offset);
+    SimpleIdentifier identifier21 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
+    JUnitTestCase.assertNotNull(identifier21.token);
+    JUnitTestCase.assertEquals("a", identifier21.name);
+    JUnitTestCase.assertEquals(5, identifier21.offset);
   }
   void test_computeStringValue_emptyInterpolationPrefix() {
     JUnitTestCase.assertEquals("", computeStringValue("'''"));
   }
   void test_computeStringValue_escape_b() {
     JUnitTestCase.assertEquals("\b", computeStringValue("'\\b'"));
   }
   void test_computeStringValue_escape_f() {
     JUnitTestCase.assertEquals("\f", computeStringValue("'\\f'"));
   }
@@ skipping 212 matching lines @@
   void test_parseAnnotation_n3_a() {
     Annotation annotation = ParserTestCase.parse5("parseAnnotation", "@A.B.C(x,y)", []);
     JUnitTestCase.assertNotNull(annotation.atSign);
     JUnitTestCase.assertNotNull(annotation.name);
     JUnitTestCase.assertNotNull(annotation.period);
     JUnitTestCase.assertNotNull(annotation.constructorName);
     JUnitTestCase.assertNotNull(annotation.arguments);
   }
   void test_parseArgument_named() {
     NamedExpression expression = ParserTestCase.parse5("parseArgument", "n: x", []);
-    Label name23 = expression.name;
-    JUnitTestCase.assertNotNull(name23);
-    JUnitTestCase.assertNotNull(name23.label);
-    JUnitTestCase.assertNotNull(name23.colon);
+    Label name26 = expression.name;
+    JUnitTestCase.assertNotNull(name26);
+    JUnitTestCase.assertNotNull(name26.label);
+    JUnitTestCase.assertNotNull(name26.colon);
     JUnitTestCase.assertNotNull(expression.expression);
   }
   void test_parseArgument_unnamed() {
     String lexeme = "x";
     SimpleIdentifier identifier = ParserTestCase.parse5("parseArgument", lexeme, []);
     JUnitTestCase.assertEquals(lexeme, identifier.name);
   }
   void test_parseArgumentDefinitionTest() {
     ArgumentDefinitionTest test = ParserTestCase.parse5("parseArgumentDefinitionTest", "?x", []);
     JUnitTestCase.assertNotNull(test.question);
     JUnitTestCase.assertNotNull(test.identifier);
   }
   void test_parseArgumentList_empty() {
     ArgumentList argumentList = ParserTestCase.parse5("parseArgumentList", "()", []);
-    NodeList<Expression> arguments8 = argumentList.arguments;
-    EngineTestCase.assertSize(0, arguments8);
+    NodeList<Expression> arguments9 = argumentList.arguments;
+    EngineTestCase.assertSize(0, arguments9);
   }
   void test_parseArgumentList_mixed() {
     ArgumentList argumentList = ParserTestCase.parse5("parseArgumentList", "(w, x, y: y, z: z)", []);
-    NodeList<Expression> arguments9 = argumentList.arguments;
-    EngineTestCase.assertSize(4, arguments9);
+    NodeList<Expression> arguments10 = argumentList.arguments;
+    EngineTestCase.assertSize(4, arguments10);
   }
   void test_parseArgumentList_noNamed() {
     ArgumentList argumentList = ParserTestCase.parse5("parseArgumentList", "(x, y, z)", []);
-    NodeList<Expression> arguments10 = argumentList.arguments;
-    EngineTestCase.assertSize(3, arguments10);
+    NodeList<Expression> arguments11 = argumentList.arguments;
+    EngineTestCase.assertSize(3, arguments11);
   }
   void test_parseArgumentList_onlyNamed() {
     ArgumentList argumentList = ParserTestCase.parse5("parseArgumentList", "(x: x, y: y)", []);
-    NodeList<Expression> arguments11 = argumentList.arguments;
-    EngineTestCase.assertSize(2, arguments11);
+    NodeList<Expression> arguments12 = argumentList.arguments;
+    EngineTestCase.assertSize(2, arguments12);
   }
   void test_parseAssertStatement() {
     AssertStatement statement = ParserTestCase.parse5("parseAssertStatement", "assert (x);", []);
     JUnitTestCase.assertNotNull(statement.keyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
     JUnitTestCase.assertNotNull(statement.condition);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.semicolon);
   }
   void test_parseAssignableExpression_expression_args_dot() {
     PropertyAccess propertyAccess = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "(x)(y).z");
     FunctionExpressionInvocation invocation = propertyAccess.target as FunctionExpressionInvocation;
     JUnitTestCase.assertNotNull(invocation.function);
-    ArgumentList argumentList12 = invocation.argumentList;
-    JUnitTestCase.assertNotNull(argumentList12);
-    EngineTestCase.assertSize(1, argumentList12.arguments);
+    ArgumentList argumentList10 = invocation.argumentList;
+    JUnitTestCase.assertNotNull(argumentList10);
+    EngineTestCase.assertSize(1, argumentList10.arguments);
     JUnitTestCase.assertNotNull(propertyAccess.operator);
     JUnitTestCase.assertNotNull(propertyAccess.propertyName);
   }
   void test_parseAssignableExpression_expression_dot() {
     PropertyAccess propertyAccess = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "(x).y");
     JUnitTestCase.assertNotNull(propertyAccess.target);
     JUnitTestCase.assertNotNull(propertyAccess.operator);
     JUnitTestCase.assertNotNull(propertyAccess.propertyName);
   }
   void test_parseAssignableExpression_expression_index() {
     IndexExpression expression = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "(x)[y]");
     JUnitTestCase.assertNotNull(expression.array);
     JUnitTestCase.assertNotNull(expression.leftBracket);
     JUnitTestCase.assertNotNull(expression.index);
     JUnitTestCase.assertNotNull(expression.rightBracket);
   }
   void test_parseAssignableExpression_identifier() {
     SimpleIdentifier identifier = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "x");
     JUnitTestCase.assertNotNull(identifier);
   }
   void test_parseAssignableExpression_identifier_args_dot() {
     PropertyAccess propertyAccess = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "x(y).z");
     MethodInvocation invocation = propertyAccess.target as MethodInvocation;
     JUnitTestCase.assertEquals("x", invocation.methodName.name);
-    ArgumentList argumentList13 = invocation.argumentList;
-    JUnitTestCase.assertNotNull(argumentList13);
-    EngineTestCase.assertSize(1, argumentList13.arguments);
+    ArgumentList argumentList11 = invocation.argumentList;
+    JUnitTestCase.assertNotNull(argumentList11);
+    EngineTestCase.assertSize(1, argumentList11.arguments);
     JUnitTestCase.assertNotNull(propertyAccess.operator);
     JUnitTestCase.assertNotNull(propertyAccess.propertyName);
   }
   void test_parseAssignableExpression_identifier_dot() {
     PropertyAccess propertyAccess = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "x.y");
     JUnitTestCase.assertNotNull(propertyAccess.target);
     JUnitTestCase.assertNotNull(propertyAccess.operator);
     JUnitTestCase.assertNotNull(propertyAccess.propertyName);
   }
   void test_parseAssignableExpression_identifier_index() {
@@ skipping 294 matching lines @@
     JUnitTestCase.assertNotNull(constructor.returnType);
     EngineTestCase.assertSize(1, constructor.initializers);
   }
   void test_parseClassMember_field_instance_prefixedType() {
     FieldDeclaration field = ParserTestCase.parse("parseClassMember", <Object> ["C"], "p.A f;");
     JUnitTestCase.assertNull(field.documentationComment);
     EngineTestCase.assertSize(0, field.metadata);
     JUnitTestCase.assertNull(field.keyword);
     VariableDeclarationList list = field.fields;
     JUnitTestCase.assertNotNull(list);
-    NodeList<VariableDeclaration> variables4 = list.variables;
-    EngineTestCase.assertSize(1, variables4);
-    VariableDeclaration variable = variables4[0];
+    NodeList<VariableDeclaration> variables5 = list.variables;
+    EngineTestCase.assertSize(1, variables5);
+    VariableDeclaration variable = variables5[0];
     JUnitTestCase.assertNotNull(variable.name);
   }
   void test_parseClassMember_field_namedGet() {
     FieldDeclaration field = ParserTestCase.parse("parseClassMember", <Object> ["C"], "var get;");
     JUnitTestCase.assertNull(field.documentationComment);
     EngineTestCase.assertSize(0, field.metadata);
     JUnitTestCase.assertNull(field.keyword);
     VariableDeclarationList list = field.fields;
     JUnitTestCase.assertNotNull(list);
-    NodeList<VariableDeclaration> variables5 = list.variables;
-    EngineTestCase.assertSize(1, variables5);
-    VariableDeclaration variable = variables5[0];
+    NodeList<VariableDeclaration> variables6 = list.variables;
+    EngineTestCase.assertSize(1, variables6);
+    VariableDeclaration variable = variables6[0];
     JUnitTestCase.assertNotNull(variable.name);
   }
   void test_parseClassMember_field_namedOperator() {
     FieldDeclaration field = ParserTestCase.parse("parseClassMember", <Object> ["C"], "var operator;");
     JUnitTestCase.assertNull(field.documentationComment);
     EngineTestCase.assertSize(0, field.metadata);
     JUnitTestCase.assertNull(field.keyword);
     VariableDeclarationList list = field.fields;
     JUnitTestCase.assertNotNull(list);
-    NodeList<VariableDeclaration> variables6 = list.variables;
-    EngineTestCase.assertSize(1, variables6);
-    VariableDeclaration variable = variables6[0];
+    NodeList<VariableDeclaration> variables7 = list.variables;
+    EngineTestCase.assertSize(1, variables7);
+    VariableDeclaration variable = variables7[0];
     JUnitTestCase.assertNotNull(variable.name);
   }
   void test_parseClassMember_field_namedSet() {
     FieldDeclaration field = ParserTestCase.parse("parseClassMember", <Object> ["C"], "var set;");
     JUnitTestCase.assertNull(field.documentationComment);
     EngineTestCase.assertSize(0, field.metadata);
     JUnitTestCase.assertNull(field.keyword);
     VariableDeclarationList list = field.fields;
     JUnitTestCase.assertNotNull(list);
-    NodeList<VariableDeclaration> variables7 = list.variables;
-    EngineTestCase.assertSize(1, variables7);
-    VariableDeclaration variable = variables7[0];
+    NodeList<VariableDeclaration> variables8 = list.variables;
+    EngineTestCase.assertSize(1, variables8);
+    VariableDeclaration variable = variables8[0];
     JUnitTestCase.assertNotNull(variable.name);
   }
   void test_parseClassMember_getter_void() {
     MethodDeclaration method = ParserTestCase.parse("parseClassMember", <Object> ["C"], "void get g {}");
     JUnitTestCase.assertNull(method.documentationComment);
     JUnitTestCase.assertNull(method.externalKeyword);
     JUnitTestCase.assertNull(method.modifierKeyword);
     JUnitTestCase.assertNotNull(method.propertyKeyword);
     JUnitTestCase.assertNotNull(method.returnType);
     JUnitTestCase.assertNotNull(method.name);
@@ skipping 189 matching lines @@
     JUnitTestCase.assertNotNull(constructor.factoryKeyword);
     JUnitTestCase.assertNotNull(constructor.returnType);
     JUnitTestCase.assertNull(constructor.period);
     JUnitTestCase.assertNull(constructor.name);
     JUnitTestCase.assertNotNull(constructor.parameters);
     JUnitTestCase.assertNotNull(constructor.separator);
     EngineTestCase.assertSize(0, constructor.initializers);
     JUnitTestCase.assertNotNull(constructor.redirectedConstructor);
     JUnitTestCase.assertNotNull(constructor.body);
   }
+  void test_parseClassTypeAlias() {
+    Token token5 = TokenFactory.token(Keyword.TYPEDEF);
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token5], "A = B;");
+    JUnitTestCase.assertNotNull(classTypeAlias.keyword);
+    JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
+    JUnitTestCase.assertNotNull(classTypeAlias.equals);
+    JUnitTestCase.assertNull(classTypeAlias.abstractKeyword);
+    JUnitTestCase.assertNotNullMsg("B", classTypeAlias.superclass.name.name);
+    JUnitTestCase.assertNull(classTypeAlias.withClause);
+    JUnitTestCase.assertNull(classTypeAlias.implementsClause);
+    JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
+  }
+  void test_parseClassTypeAlias_abstract() {
+    Token token6 = TokenFactory.token(Keyword.TYPEDEF);
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token6], "A = abstract B;");
+    JUnitTestCase.assertNotNull(classTypeAlias.keyword);
+    JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
+    JUnitTestCase.assertNotNull(classTypeAlias.equals);
+    JUnitTestCase.assertNotNull(classTypeAlias.abstractKeyword);
+    JUnitTestCase.assertNotNullMsg("B", classTypeAlias.superclass.name.name);
+    JUnitTestCase.assertNull(classTypeAlias.withClause);
+    JUnitTestCase.assertNull(classTypeAlias.implementsClause);
+    JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
+  }
+  void test_parseClassTypeAlias_implements() {
+    Token token7 = TokenFactory.token(Keyword.TYPEDEF);
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token7], "A = B implements C;");
+    JUnitTestCase.assertNotNull(classTypeAlias.keyword);
+    JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
+    JUnitTestCase.assertNotNull(classTypeAlias.equals);
+    JUnitTestCase.assertNull(classTypeAlias.abstractKeyword);
+    JUnitTestCase.assertNotNullMsg("B", classTypeAlias.superclass.name.name);
+    JUnitTestCase.assertNull(classTypeAlias.withClause);
+    JUnitTestCase.assertNotNull(classTypeAlias.implementsClause);
+    JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
+  }
+  void test_parseClassTypeAlias_with() {
+    Token token8 = TokenFactory.token(Keyword.TYPEDEF);
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token8], "A = B with C;");
+    JUnitTestCase.assertNotNull(classTypeAlias.keyword);
+    JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
+    JUnitTestCase.assertNotNull(classTypeAlias.equals);
+    JUnitTestCase.assertNull(classTypeAlias.abstractKeyword);
+    JUnitTestCase.assertNotNullMsg("B", classTypeAlias.superclass.name.name);
+    JUnitTestCase.assertNotNull(classTypeAlias.withClause);
+    JUnitTestCase.assertNull(classTypeAlias.implementsClause);
+    JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
+  }
+  void test_parseClassTypeAlias_with_implements() {
+    Token token9 = TokenFactory.token(Keyword.TYPEDEF);
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token9], "A = B with C implements D;");
+    JUnitTestCase.assertNotNull(classTypeAlias.keyword);
+    JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
+    JUnitTestCase.assertNotNull(classTypeAlias.equals);
+    JUnitTestCase.assertNull(classTypeAlias.abstractKeyword);
+    JUnitTestCase.assertNotNullMsg("B", classTypeAlias.superclass.name.name);
+    JUnitTestCase.assertNotNull(classTypeAlias.withClause);
+    JUnitTestCase.assertNotNull(classTypeAlias.implementsClause);
+    JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
+  }
   void test_parseCombinators_h() {
     List<Combinator> combinators = ParserTestCase.parse5("parseCombinators", "hide a;", []);
     EngineTestCase.assertSize(1, combinators);
     HideCombinator combinator = combinators[0] as HideCombinator;
     JUnitTestCase.assertNotNull(combinator);
     JUnitTestCase.assertNotNull(combinator.keyword);
     EngineTestCase.assertSize(1, combinator.hiddenNames);
   }
   void test_parseCombinators_hs() {
     List<Combinator> combinators = ParserTestCase.parse5("parseCombinators", "hide a show b;", []);
@@ skipping 60 matching lines @@
     EngineTestCase.assertSize(2, commentAndMetadata.metadata);
   }
   void test_parseCommentAndMetadata_none() {
     CommentAndMetadata commentAndMetadata = ParserTestCase.parse5("parseCommentAndMetadata", "void", []);
     JUnitTestCase.assertNull(commentAndMetadata.comment);
     EngineTestCase.assertSize(0, commentAndMetadata.metadata);
   }
   void test_parseCommentReference_new_prefixed() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["new a.b", 7], "");
     PrefixedIdentifier prefixedIdentifier = EngineTestCase.assertInstanceOf(PrefixedIdentifier, reference.identifier);
+    SimpleIdentifier prefix10 = prefixedIdentifier.prefix;
+    JUnitTestCase.assertNotNull(prefix10.token);
+    JUnitTestCase.assertEquals("a", prefix10.name);
+    JUnitTestCase.assertEquals(11, prefix10.offset);
+    JUnitTestCase.assertNotNull(prefixedIdentifier.period);
+    SimpleIdentifier identifier22 = prefixedIdentifier.identifier;
+    JUnitTestCase.assertNotNull(identifier22.token);
+    JUnitTestCase.assertEquals("b", identifier22.name);
+    JUnitTestCase.assertEquals(13, identifier22.offset);
+  }
+  void test_parseCommentReference_new_simple() {
+    CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["new a", 5], "");
+    SimpleIdentifier identifier23 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
+    JUnitTestCase.assertNotNull(identifier23.token);
+    JUnitTestCase.assertEquals("a", identifier23.name);
+    JUnitTestCase.assertEquals(9, identifier23.offset);
+  }
+  void test_parseCommentReference_prefixed() {
+    CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["a.b", 7], "");
+    PrefixedIdentifier prefixedIdentifier = EngineTestCase.assertInstanceOf(PrefixedIdentifier, reference.identifier);
     SimpleIdentifier prefix11 = prefixedIdentifier.prefix;
     JUnitTestCase.assertNotNull(prefix11.token);
     JUnitTestCase.assertEquals("a", prefix11.name);
-    JUnitTestCase.assertEquals(11, prefix11.offset);
+    JUnitTestCase.assertEquals(7, prefix11.offset);
     JUnitTestCase.assertNotNull(prefixedIdentifier.period);
-    SimpleIdentifier identifier20 = prefixedIdentifier.identifier;
-    JUnitTestCase.assertNotNull(identifier20.token);
-    JUnitTestCase.assertEquals("b", identifier20.name);
-    JUnitTestCase.assertEquals(13, identifier20.offset);
-  }
-  void test_parseCommentReference_new_simple() {
-    CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["new a", 5], "");
-    SimpleIdentifier identifier21 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
-    JUnitTestCase.assertNotNull(identifier21.token);
-    JUnitTestCase.assertEquals("a", identifier21.name);
-    JUnitTestCase.assertEquals(9, identifier21.offset);
-  }
-  void test_parseCommentReference_prefixed() {
-    CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["a.b", 7], "");
-    PrefixedIdentifier prefixedIdentifier = EngineTestCase.assertInstanceOf(PrefixedIdentifier, reference.identifier);
-    SimpleIdentifier prefix12 = prefixedIdentifier.prefix;
-    JUnitTestCase.assertNotNull(prefix12.token);
-    JUnitTestCase.assertEquals("a", prefix12.name);
-    JUnitTestCase.assertEquals(7, prefix12.offset);
-    JUnitTestCase.assertNotNull(prefixedIdentifier.period);
-    SimpleIdentifier identifier22 = prefixedIdentifier.identifier;
-    JUnitTestCase.assertNotNull(identifier22.token);
-    JUnitTestCase.assertEquals("b", identifier22.name);
-    JUnitTestCase.assertEquals(9, identifier22.offset);
+    SimpleIdentifier identifier24 = prefixedIdentifier.identifier;
+    JUnitTestCase.assertNotNull(identifier24.token);
+    JUnitTestCase.assertEquals("b", identifier24.name);
+    JUnitTestCase.assertEquals(9, identifier24.offset);
   }
   void test_parseCommentReference_simple() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["a", 5], "");
-    SimpleIdentifier identifier23 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
-    JUnitTestCase.assertNotNull(identifier23.token);
-    JUnitTestCase.assertEquals("a", identifier23.name);
-    JUnitTestCase.assertEquals(5, identifier23.offset);
+    SimpleIdentifier identifier25 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
+    JUnitTestCase.assertNotNull(identifier25.token);
+    JUnitTestCase.assertEquals("a", identifier25.name);
+    JUnitTestCase.assertEquals(5, identifier25.offset);
   }
   void test_parseCommentReferences_multiLine() {
     List<Token> tokens = <Token> [new StringToken(TokenType.MULTI_LINE_COMMENT, "/** xxx [a] yyy [b] zzz */", 3)];
     List<CommentReference> references = ParserTestCase.parse("parseCommentReferences", <Object> [tokens], "");
     EngineTestCase.assertSize(2, references);
     CommentReference reference = references[0];
     JUnitTestCase.assertNotNull(reference);
     JUnitTestCase.assertNotNull(reference.identifier);
     JUnitTestCase.assertEquals(12, reference.offset);
     reference = references[1];
@@ skipping 113 matching lines @@
   void test_parseCompilationUnitMember_function_noType() {
     FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "f() {}");
     JUnitTestCase.assertNotNull(declaration.functionExpression);
     JUnitTestCase.assertNull(declaration.propertyKeyword);
   }
   void test_parseCompilationUnitMember_function_type() {
     FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "int f() {}");
     JUnitTestCase.assertNotNull(declaration.functionExpression);
     JUnitTestCase.assertNull(declaration.propertyKeyword);
   }
+  void test_parseCompilationUnitMember_function_void() {
+    FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "void f() {}");
+    JUnitTestCase.assertNotNull(declaration.returnType);
+  }
   void test_parseCompilationUnitMember_getter_external_noType() {
     FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "external get p;");
     JUnitTestCase.assertNotNull(declaration.externalKeyword);
     JUnitTestCase.assertNotNull(declaration.functionExpression);
     JUnitTestCase.assertNotNull(declaration.propertyKeyword);
   }
   void test_parseCompilationUnitMember_getter_external_type() {
     FunctionDeclaration declaration = ParserTestCase.parse("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "external int get p;");
     JUnitTestCase.assertNotNull(declaration.externalKeyword);
     JUnitTestCase.assertNotNull(declaration.functionExpression);
@@ skipping 681 matching lines @@
     JUnitTestCase.assertNotNull(statement.condition);
     JUnitTestCase.assertNotNull(statement.rightSeparator);
     EngineTestCase.assertSize(1, statement.updaters);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
   void test_parseForStatement_loop_i() {
     ForStatement statement = ParserTestCase.parse5("parseForStatement", "for (var i = 0;;) {}", []);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
-    VariableDeclarationList variables8 = statement.variables;
-    JUnitTestCase.assertNotNull(variables8);
-    EngineTestCase.assertSize(0, variables8.metadata);
-    EngineTestCase.assertSize(1, variables8.variables);
+    VariableDeclarationList variables9 = statement.variables;
+    JUnitTestCase.assertNotNull(variables9);
+    EngineTestCase.assertSize(0, variables9.metadata);
+    EngineTestCase.assertSize(1, variables9.variables);
     JUnitTestCase.assertNull(statement.initialization);
     JUnitTestCase.assertNotNull(statement.leftSeparator);
     JUnitTestCase.assertNull(statement.condition);
     JUnitTestCase.assertNotNull(statement.rightSeparator);
     EngineTestCase.assertSize(0, statement.updaters);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
   void test_parseForStatement_loop_i_withMetadata() {
     ForStatement statement = ParserTestCase.parse5("parseForStatement", "for (@A var i = 0;;) {}", []);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
-    VariableDeclarationList variables9 = statement.variables;
-    JUnitTestCase.assertNotNull(variables9);
-    EngineTestCase.assertSize(1, variables9.metadata);
-    EngineTestCase.assertSize(1, variables9.variables);
+    VariableDeclarationList variables10 = statement.variables;
+    JUnitTestCase.assertNotNull(variables10);
+    EngineTestCase.assertSize(1, variables10.metadata);
+    EngineTestCase.assertSize(1, variables10.variables);
     JUnitTestCase.assertNull(statement.initialization);
     JUnitTestCase.assertNotNull(statement.leftSeparator);
     JUnitTestCase.assertNull(statement.condition);
     JUnitTestCase.assertNotNull(statement.rightSeparator);
     EngineTestCase.assertSize(0, statement.updaters);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
   void test_parseForStatement_loop_ic() {
     ForStatement statement = ParserTestCase.parse5("parseForStatement", "for (var i = 0; i < count;) {}", []);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
-    VariableDeclarationList variables10 = statement.variables;
-    JUnitTestCase.assertNotNull(variables10);
-    EngineTestCase.assertSize(1, variables10.variables);
+    VariableDeclarationList variables11 = statement.variables;
+    JUnitTestCase.assertNotNull(variables11);
+    EngineTestCase.assertSize(1, variables11.variables);
     JUnitTestCase.assertNull(statement.initialization);
     JUnitTestCase.assertNotNull(statement.leftSeparator);
     JUnitTestCase.assertNotNull(statement.condition);
     JUnitTestCase.assertNotNull(statement.rightSeparator);
     EngineTestCase.assertSize(0, statement.updaters);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
   void test_parseForStatement_loop_icu() {
     ForStatement statement = ParserTestCase.parse5("parseForStatement", "for (var i = 0; i < count; i++) {}", []);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
-    VariableDeclarationList variables11 = statement.variables;
-    JUnitTestCase.assertNotNull(variables11);
-    EngineTestCase.assertSize(1, variables11.variables);
+    VariableDeclarationList variables12 = statement.variables;
+    JUnitTestCase.assertNotNull(variables12);
+    EngineTestCase.assertSize(1, variables12.variables);
     JUnitTestCase.assertNull(statement.initialization);
     JUnitTestCase.assertNotNull(statement.leftSeparator);
     JUnitTestCase.assertNotNull(statement.condition);
     JUnitTestCase.assertNotNull(statement.rightSeparator);
     EngineTestCase.assertSize(1, statement.updaters);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
   void test_parseForStatement_loop_iicuu() {
     ForStatement statement = ParserTestCase.parse5("parseForStatement", "for (int i = 0, j = count; i < j; i++, j--) {}", []);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
-    VariableDeclarationList variables12 = statement.variables;
-    JUnitTestCase.assertNotNull(variables12);
-    EngineTestCase.assertSize(2, variables12.variables);
+    VariableDeclarationList variables13 = statement.variables;
+    JUnitTestCase.assertNotNull(variables13);
+    EngineTestCase.assertSize(2, variables13.variables);
     JUnitTestCase.assertNull(statement.initialization);
     JUnitTestCase.assertNotNull(statement.leftSeparator);
     JUnitTestCase.assertNotNull(statement.condition);
     JUnitTestCase.assertNotNull(statement.rightSeparator);
     EngineTestCase.assertSize(2, statement.updaters);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
   void test_parseForStatement_loop_iu() {
     ForStatement statement = ParserTestCase.parse5("parseForStatement", "for (var i = 0;; i++) {}", []);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
-    VariableDeclarationList variables13 = statement.variables;
-    JUnitTestCase.assertNotNull(variables13);
-    EngineTestCase.assertSize(1, variables13.variables);
+    VariableDeclarationList variables14 = statement.variables;
+    JUnitTestCase.assertNotNull(variables14);
+    EngineTestCase.assertSize(1, variables14.variables);
     JUnitTestCase.assertNull(statement.initialization);
     JUnitTestCase.assertNotNull(statement.leftSeparator);
     JUnitTestCase.assertNull(statement.condition);
     JUnitTestCase.assertNotNull(statement.rightSeparator);
     EngineTestCase.assertSize(1, statement.updaters);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
   void test_parseForStatement_loop_u() {
     ForStatement statement = ParserTestCase.parse5("parseForStatement", "for (;; i++) {}", []);
@@ skipping 15 matching lines @@
   void test_parseFunctionBody_empty() {
     EmptyFunctionBody functionBody = ParserTestCase.parse("parseFunctionBody", <Object> [true, false], ";");
     JUnitTestCase.assertNotNull(functionBody.semicolon);
   }
   void test_parseFunctionBody_expression() {
     ExpressionFunctionBody functionBody = ParserTestCase.parse("parseFunctionBody", <Object> [false, false], "=> y;");
     JUnitTestCase.assertNotNull(functionBody.functionDefinition);
     JUnitTestCase.assertNotNull(functionBody.expression);
     JUnitTestCase.assertNotNull(functionBody.semicolon);
   }
+  void test_parseFunctionBody_nativeFunctionBody() {
+    NativeFunctionBody functionBody = ParserTestCase.parse("parseFunctionBody", <Object> [false, false], "native 'str';");
+    JUnitTestCase.assertNotNull(functionBody.nativeToken);
+    JUnitTestCase.assertNotNull(functionBody.stringLiteral);
+    JUnitTestCase.assertNotNull(functionBody.semicolon);
+  }
   void test_parseFunctionDeclaration_function() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     TypeName returnType = new TypeName.full(new SimpleIdentifier.full(null), null);
     FunctionDeclaration declaration = ParserTestCase.parse("parseFunctionDeclaration", <Object> [commentAndMetadata(comment, []), null, returnType], "f() {}");
     JUnitTestCase.assertEquals(comment, declaration.documentationComment);
     JUnitTestCase.assertEquals(returnType, declaration.returnType);
     JUnitTestCase.assertNotNull(declaration.name);
     FunctionExpression expression = declaration.functionExpression;
     JUnitTestCase.assertNotNull(expression);
     JUnitTestCase.assertNotNull(expression.body);
@@ skipping 204 matching lines @@
     JUnitTestCase.assertEquals(comment, declaration.documentationComment);
     VariableDeclarationList fields5 = declaration.fields;
     JUnitTestCase.assertNotNull(fields5);
     JUnitTestCase.assertEquals(varKeyword, fields5.keyword);
     JUnitTestCase.assertNull(fields5.type);
     EngineTestCase.assertSize(3, fields5.variables);
     JUnitTestCase.assertEquals(staticKeyword, declaration.keyword);
     JUnitTestCase.assertNotNull(declaration.semicolon);
   }
   void test_parseInstanceCreationExpression_qualifiedType() {
-    Token token5 = TokenFactory.token(Keyword.NEW);
-    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token5], "A.B()");
-    JUnitTestCase.assertEquals(token5, expression.keyword);
+    Token token10 = TokenFactory.token(Keyword.NEW);
+    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token10], "A.B()");
+    JUnitTestCase.assertEquals(token10, expression.keyword);
     ConstructorName name = expression.constructorName;
     JUnitTestCase.assertNotNull(name);
     JUnitTestCase.assertNotNull(name.type);
     JUnitTestCase.assertNull(name.period);
     JUnitTestCase.assertNull(name.name);
     JUnitTestCase.assertNotNull(expression.argumentList);
   }
   void test_parseInstanceCreationExpression_qualifiedType_named() {
-    Token token6 = TokenFactory.token(Keyword.NEW);
-    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token6], "A.B.c()");
-    JUnitTestCase.assertEquals(token6, expression.keyword);
+    Token token11 = TokenFactory.token(Keyword.NEW);
+    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token11], "A.B.c()");
+    JUnitTestCase.assertEquals(token11, expression.keyword);
     ConstructorName name = expression.constructorName;
     JUnitTestCase.assertNotNull(name);
     JUnitTestCase.assertNotNull(name.type);
     JUnitTestCase.assertNotNull(name.period);
     JUnitTestCase.assertNotNull(name.name);
     JUnitTestCase.assertNotNull(expression.argumentList);
   }
   void test_parseInstanceCreationExpression_type() {
-    Token token7 = TokenFactory.token(Keyword.NEW);
-    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token7], "A()");
-    JUnitTestCase.assertEquals(token7, expression.keyword);
+    Token token12 = TokenFactory.token(Keyword.NEW);
+    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token12], "A()");
+    JUnitTestCase.assertEquals(token12, expression.keyword);
     ConstructorName name = expression.constructorName;
     JUnitTestCase.assertNotNull(name);
     JUnitTestCase.assertNotNull(name.type);
     JUnitTestCase.assertNull(name.period);
     JUnitTestCase.assertNull(name.name);
     JUnitTestCase.assertNotNull(expression.argumentList);
   }
   void test_parseInstanceCreationExpression_type_named() {
-    Token token8 = TokenFactory.token(Keyword.NEW);
-    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token8], "A<B>.c()");
-    JUnitTestCase.assertEquals(token8, expression.keyword);
+    Token token13 = TokenFactory.token(Keyword.NEW);
+    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token13], "A<B>.c()");
+    JUnitTestCase.assertEquals(token13, expression.keyword);
     ConstructorName name = expression.constructorName;
     JUnitTestCase.assertNotNull(name);
     JUnitTestCase.assertNotNull(name.type);
     JUnitTestCase.assertNotNull(name.period);
     JUnitTestCase.assertNotNull(name.name);
     JUnitTestCase.assertNotNull(expression.argumentList);
   }
   void test_parseLibraryDirective() {
     LibraryDirective directive = ParserTestCase.parse("parseLibraryDirective", <Object> [emptyCommentAndMetadata()], "library l;");
     JUnitTestCase.assertNotNull(directive.libraryToken);
     JUnitTestCase.assertNotNull(directive.name);
     JUnitTestCase.assertNotNull(directive.semicolon);
   }
   void test_parseLibraryIdentifier_multiple() {
     String name = "a.b.c";
     LibraryIdentifier identifier = ParserTestCase.parse5("parseLibraryIdentifier", name, []);
     JUnitTestCase.assertEquals(name, identifier.name);
   }
   void test_parseLibraryIdentifier_single() {
     String name = "a";
     LibraryIdentifier identifier = ParserTestCase.parse5("parseLibraryIdentifier", name, []);
     JUnitTestCase.assertEquals(name, identifier.name);
   }
   void test_parseListLiteral_empty_oneToken() {
-    Token token9 = TokenFactory.token(Keyword.CONST);
+    Token token14 = TokenFactory.token(Keyword.CONST);
     TypeArgumentList typeArguments = new TypeArgumentList.full(null, null, null);
-    ListLiteral literal = ParserTestCase.parse("parseListLiteral", <Object> [token9, typeArguments], "[]");
-    JUnitTestCase.assertEquals(token9, literal.modifier);
+    ListLiteral literal = ParserTestCase.parse("parseListLiteral", <Object> [token14, typeArguments], "[]");
+    JUnitTestCase.assertEquals(token14, literal.modifier);
     JUnitTestCase.assertEquals(typeArguments, literal.typeArguments);
     JUnitTestCase.assertNotNull(literal.leftBracket);
     EngineTestCase.assertSize(0, literal.elements);
     JUnitTestCase.assertNotNull(literal.rightBracket);
   }
   void test_parseListLiteral_empty_twoTokens() {
-    Token token10 = TokenFactory.token(Keyword.CONST);
+    Token token15 = TokenFactory.token(Keyword.CONST);
     TypeArgumentList typeArguments = new TypeArgumentList.full(null, null, null);
-    ListLiteral literal = ParserTestCase.parse("parseListLiteral", <Object> [token10, typeArguments], "[ ]");
-    JUnitTestCase.assertEquals(token10, literal.modifier);
+    ListLiteral literal = ParserTestCase.parse("parseListLiteral", <Object> [token15, typeArguments], "[ ]");
+    JUnitTestCase.assertEquals(token15, literal.modifier);
     JUnitTestCase.assertEquals(typeArguments, literal.typeArguments);
     JUnitTestCase.assertNotNull(literal.leftBracket);
     EngineTestCase.assertSize(0, literal.elements);
     JUnitTestCase.assertNotNull(literal.rightBracket);
   }
   void test_parseListLiteral_multiple() {
     ListLiteral literal = ParserTestCase.parse("parseListLiteral", <Object> [null, null], "[1, 2, 3]");
     JUnitTestCase.assertNull(literal.modifier);
     JUnitTestCase.assertNull(literal.typeArguments);
     JUnitTestCase.assertNotNull(literal.leftBracket);
@@ skipping 48 matching lines @@
     JUnitTestCase.assertNotNull(expression.rightOperand);
   }
   void test_parseLogicalOrExpression() {
     BinaryExpression expression = ParserTestCase.parse5("parseLogicalOrExpression", "x || y", []);
     JUnitTestCase.assertNotNull(expression.leftOperand);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.BAR_BAR, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.rightOperand);
   }
   void test_parseMapLiteral_empty() {
-    Token token11 = TokenFactory.token(Keyword.CONST);
+    Token token16 = TokenFactory.token(Keyword.CONST);
     TypeArgumentList typeArguments = new TypeArgumentList.full(null, null, null);
-    MapLiteral literal = ParserTestCase.parse("parseMapLiteral", <Object> [token11, typeArguments], "{}");
-    JUnitTestCase.assertEquals(token11, literal.modifier);
+    MapLiteral literal = ParserTestCase.parse("parseMapLiteral", <Object> [token16, typeArguments], "{}");
+    JUnitTestCase.assertEquals(token16, literal.modifier);
     JUnitTestCase.assertEquals(typeArguments, literal.typeArguments);
     JUnitTestCase.assertNotNull(literal.leftBracket);
     EngineTestCase.assertSize(0, literal.entries);
     JUnitTestCase.assertNotNull(literal.rightBracket);
   }
   void test_parseMapLiteral_multiple() {
     MapLiteral literal = ParserTestCase.parse("parseMapLiteral", <Object> [null, null], "{'a' : b, 'x' : y}");
     JUnitTestCase.assertNotNull(literal.leftBracket);
     EngineTestCase.assertSize(2, literal.entries);
     JUnitTestCase.assertNotNull(literal.rightBracket);
@@ skipping 1179 matching lines @@
     JUnitTestCase.assertNotNull(following);
     JUnitTestCase.assertEquals(TokenType.PLUS, following.type);
   }
   /**
    * Invoke the method {@link Parser#computeStringValue(String)} with the given argument.
    * @param lexeme the argument to the method
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    */
   String computeStringValue(String lexeme) {
-    AnalysisErrorListener listener = new AnalysisErrorListener_15();
+    AnalysisErrorListener listener = new AnalysisErrorListener_19();
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(parser, "computeStringValue", <Object> [lexeme], null) as String;
   }
   /**
    * Invoke the method {@link Parser#createSyntheticIdentifier()} with the parser set to the token
    * stream produced by scanning the given source.
    * @param source the source to be scanned to produce the token stream being tested
    * @return the result of invoking the method
    * @throws Exception if the method could not be invoked or throws an exception
    */
@@ skipping 610 matching lines @@
         runJUnitTest(__test, __test.test_parseClassMember_operator_indexAssign);
       });
       _ut.test('test_parseClassMember_redirectingFactory_const', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseClassMember_redirectingFactory_const);
       });
       _ut.test('test_parseClassMember_redirectingFactory_nonConst', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseClassMember_redirectingFactory_nonConst);
       });
+      _ut.test('test_parseClassTypeAlias', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseClassTypeAlias);
+      });
+      _ut.test('test_parseClassTypeAlias_abstract', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseClassTypeAlias_abstract);
+      });
+      _ut.test('test_parseClassTypeAlias_implements', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseClassTypeAlias_implements);
+      });
+      _ut.test('test_parseClassTypeAlias_with', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseClassTypeAlias_with);
+      });
+      _ut.test('test_parseClassTypeAlias_with_implements', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseClassTypeAlias_with_implements);
+      });
       _ut.test('test_parseCombinators_h', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseCombinators_h);
       });
       _ut.test('test_parseCombinators_hs', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseCombinators_hs);
       });
       _ut.test('test_parseCombinators_hshs', () {
         final __test = new SimpleParserTest();
@@ skipping 88 matching lines @@
         runJUnitTest(__test, __test.test_parseCompilationUnitMember_function_external_type);
       });
       _ut.test('test_parseCompilationUnitMember_function_noType', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseCompilationUnitMember_function_noType);
       });
       _ut.test('test_parseCompilationUnitMember_function_type', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseCompilationUnitMember_function_type);
       });
+      _ut.test('test_parseCompilationUnitMember_function_void', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseCompilationUnitMember_function_void);
+      });
       _ut.test('test_parseCompilationUnitMember_getter_external_noType', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseCompilationUnitMember_getter_external_noType);
       });
       _ut.test('test_parseCompilationUnitMember_getter_external_type', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseCompilationUnitMember_getter_external_type);
       });
       _ut.test('test_parseCompilationUnitMember_getter_noType', () {
         final __test = new SimpleParserTest();
@@ skipping 420 matching lines @@
         runJUnitTest(__test, __test.test_parseFunctionBody_block);
       });
       _ut.test('test_parseFunctionBody_empty', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseFunctionBody_empty);
       });
       _ut.test('test_parseFunctionBody_expression', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseFunctionBody_expression);
       });
+      _ut.test('test_parseFunctionBody_nativeFunctionBody', () {
+        final __test = new SimpleParserTest();
+        runJUnitTest(__test, __test.test_parseFunctionBody_nativeFunctionBody);
+      });
       _ut.test('test_parseFunctionDeclarationStatement', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseFunctionDeclarationStatement);
       });
       _ut.test('test_parseFunctionDeclaration_function', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseFunctionDeclaration_function);
       });
       _ut.test('test_parseFunctionDeclaration_getter', () {
         final __test = new SimpleParserTest();
@@ skipping 903 matching lines @@
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_skipTypeName_parameterized);
       });
       _ut.test('test_skipTypeName_simple', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_skipTypeName_simple);
       });
     });
   }
 }
-class AnalysisErrorListener_15 implements AnalysisErrorListener {
+class AnalysisErrorListener_19 implements AnalysisErrorListener {
   void onError(AnalysisError event) {
     JUnitTestCase.fail("Unexpected compilation error: ${event.message} (${event.offset}, ${event.length})");
   }
 }
 /**
  * The class {@code 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.
  * <p>
  * Simpler tests should be defined in the class {@link SimpleParserTest}.
@@ skipping 103 matching lines @@
     EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
   }
   void test_bitwiseXorExpression_precedence_and_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("x ^ y & z", []);
     EngineTestCase.assertInstanceOf(BinaryExpression, expression.rightOperand);
   }
   void test_bitwiseXorExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super ^ y ^ z", []);
     EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
   }
+  void test_cascade_withAssignment() {
+    CascadeExpression cascade = ParserTestCase.parseExpression("new Map()..[3] = 4 ..[0] = 11;", []);
+    Expression target4 = cascade.target;
+    for (Expression section in cascade.cascadeSections) {
+      EngineTestCase.assertInstanceOf(AssignmentExpression, section);
+      Expression lhs = ((section as AssignmentExpression)).leftHandSide;
+      EngineTestCase.assertInstanceOf(IndexExpression, lhs);
+      IndexExpression index = lhs as IndexExpression;
+      JUnitTestCase.assertTrue(index.isCascaded());
+      JUnitTestCase.assertSame(target4, index.realTarget);
+    }
+  }
   void test_conditionalExpression_precedence_argumentDefinitionTest_not() {
     ConditionalExpression conditional = ParserTestCase.parseExpression("!?a?!?b:!?c", []);
     EngineTestCase.assertInstanceOf(PrefixExpression, conditional.condition);
     EngineTestCase.assertInstanceOf(ArgumentDefinitionTest, ((conditional.condition as PrefixExpression)).operand);
     EngineTestCase.assertInstanceOf(PrefixExpression, conditional.thenExpression);
     EngineTestCase.assertInstanceOf(ArgumentDefinitionTest, ((conditional.thenExpression as PrefixExpression)).operand);
     EngineTestCase.assertInstanceOf(PrefixExpression, conditional.elseExpression);
     EngineTestCase.assertInstanceOf(ArgumentDefinitionTest, ((conditional.elseExpression as PrefixExpression)).operand);
   }
   void test_conditionalExpression_precedence_logicalOrExpression() {
@@ skipping 173 matching lines @@
         runJUnitTest(__test, __test.test_bitwiseXorExpression_precedence_and_left);
       });
       _ut.test('test_bitwiseXorExpression_precedence_and_right', () {
         final __test = new ComplexParserTest();
         runJUnitTest(__test, __test.test_bitwiseXorExpression_precedence_and_right);
       });
       _ut.test('test_bitwiseXorExpression_super', () {
         final __test = new ComplexParserTest();
         runJUnitTest(__test, __test.test_bitwiseXorExpression_super);
       });
+      _ut.test('test_cascade_withAssignment', () {
+        final __test = new ComplexParserTest();
+        runJUnitTest(__test, __test.test_cascade_withAssignment);
+      });
       _ut.test('test_conditionalExpression_precedence_argumentDefinitionTest_not', () {
         final __test = new ComplexParserTest();
         runJUnitTest(__test, __test.test_conditionalExpression_precedence_argumentDefinitionTest_not);
       });
       _ut.test('test_conditionalExpression_precedence_logicalOrExpression', () {
         final __test = new ComplexParserTest();
         runJUnitTest(__test, __test.test_conditionalExpression_precedence_logicalOrExpression);
       });
       _ut.test('test_constructor_initializer_withParenthesizedExpression', () {
         final __test = new ComplexParserTest();
@@ skipping 108 matching lines @@
   }
   Object visitNode(ASTNode node) {
     validate(node);
     return super.visitNode(node);
   }
   /**
    * Validate that the given AST node is correctly constructed.
    * @param node the AST node being validated
    */
   void validate(ASTNode node) {
-    ASTNode parent22 = node.parent;
+    ASTNode parent21 = node.parent;
     if (node is CompilationUnit) {
-      if (parent22 != null) {
+      if (parent21 != null) {
         _errors.add("Compilation units should not have a parent");
       }
     } else {
-      if (parent22 == null) {
+      if (parent21 == null) {
         _errors.add("No parent for ${node.runtimeType.toString()}");
       }
     }
     if (node.beginToken == null) {
       _errors.add("No begin token for ${node.runtimeType.toString()}");
     }
     if (node.endToken == null) {
       _errors.add("No end token for ${node.runtimeType.toString()}");
     }
     int nodeStart = node.offset;
     int nodeLength = node.length;
     if (nodeStart < 0 || nodeLength < 0) {
       _errors.add("No source info for ${node.runtimeType.toString()}");
     }
-    if (parent22 != null) {
+    if (parent21 != null) {
       int nodeEnd = nodeStart + nodeLength;
-      int parentStart = parent22.offset;
-      int parentEnd = parentStart + parent22.length;
+      int parentStart = parent21.offset;
+      int parentEnd = parentStart + parent21.length;
       if (nodeStart < parentStart) {
-        _errors.add("Invalid source start (${nodeStart}) for ${node.runtimeType.toString()} inside ${parent22.runtimeType.toString()} (${parentStart})");
+        _errors.add("Invalid source start (${nodeStart}) for ${node.runtimeType.toString()} inside ${parent21.runtimeType.toString()} (${parentStart})");
       }
       if (nodeEnd > parentEnd) {
-        _errors.add("Invalid source end (${nodeEnd}) for ${node.runtimeType.toString()} inside ${parent22.runtimeType.toString()} (${parentStart})");
+        _errors.add("Invalid source end (${nodeEnd}) for ${node.runtimeType.toString()} inside ${parent21.runtimeType.toString()} (${parentStart})");
       }
     }
   }
 }
 class ParserTestCase extends EngineTestCase {
   /**
    * An empty array of objects used as arguments to zero-argument methods.
    */
   static List<Object> _EMPTY_ARGUMENTS = new List<Object>(0);
   /**
@@ skipping 158 matching lines @@
    * @throws Exception if the method could not be invoked or throws an exception
    * @throws AssertionFailedError if the result is {@code null} or the errors produced while
    * scanning and parsing the source do not match the expected errors
    */
   static Object invokeParserMethod(String methodName, List<Object> objects, String source, GatheringErrorListener listener) {
     StringScanner scanner = new StringScanner(null, source, listener);
     Token tokenStream = scanner.tokenize();
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Parser parser = new Parser(null, listener);
     Object result = invokeParserMethodImpl(parser, methodName, objects, tokenStream);
-    JUnitTestCase.assertNotNull(result);
+    if (!listener.hasErrors()) {
+      JUnitTestCase.assertNotNull(result);
+    }
     return result as Object;
   }
   /**
    * Invoke a method in {@link Parser}. The method is assumed to have no arguments.
    * <p>
    * The given source is scanned and the parser is initialized to start with the first token in the
    * source before the method is invoked.
    * @param methodName the name of the method that should be invoked
    * @param source the source to be processed by the parse method
    * @param listener the error listener that will be used for both scanning and parsing
@@ skipping 267 matching lines @@
   void test_isExpression_noType() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("class Bar<T extends Foo> {m(x){if (x is ) return;if (x is !)}}", [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.MISSING_STATEMENT]);
     ClassDeclaration declaration = unit.declarations[0] as ClassDeclaration;
     MethodDeclaration method = declaration.members[0] as MethodDeclaration;
     BlockFunctionBody body5 = method.body as BlockFunctionBody;
     IfStatement ifStatement = body5.block.statements[1] as IfStatement;
     IsExpression expression = ifStatement.condition as IsExpression;
     JUnitTestCase.assertNotNull(expression.expression);
     JUnitTestCase.assertNotNull(expression.isOperator);
     JUnitTestCase.assertNotNull(expression.notOperator);
-    TypeName type29 = expression.type;
-    JUnitTestCase.assertNotNull(type29);
-    JUnitTestCase.assertTrue(type29.name.isSynthetic());
+    TypeName type37 = expression.type;
+    JUnitTestCase.assertNotNull(type37);
+    JUnitTestCase.assertTrue(type37.name.isSynthetic());
     EngineTestCase.assertInstanceOf(EmptyStatement, ifStatement.thenStatement);
   }
   void test_logicalAndExpression_missing_LHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("&& y", []);
     EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic());
   }
   void test_logicalAndExpression_missing_LHS_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("&&", []);
     EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
@@ skipping 471 matching lines @@
   }
   void fail_invalidCommentReference__new_tooMuch() {
     ParserTestCase.parse4("parseCommentReference", <Object> ["new a.b.c.d", 0], "", [ParserErrorCode.INVALID_COMMENT_REFERENCE]);
   }
   void fail_invalidCommentReference__nonNew_nonIdentifier() {
     ParserTestCase.parse4("parseCommentReference", <Object> ["42", 0], "", [ParserErrorCode.INVALID_COMMENT_REFERENCE]);
   }
   void fail_invalidCommentReference__nonNew_tooMuch() {
     ParserTestCase.parse4("parseCommentReference", <Object> ["a.b.c.d", 0], "", [ParserErrorCode.INVALID_COMMENT_REFERENCE]);
   }
+  void fail_missingClosingParenthesis() {
+    ParserTestCase.parse5("parseFormalParameterList", "(int a, int b ;", [ParserErrorCode.MISSING_CLOSING_PARENTHESIS]);
+  }
   void fail_missingExpressionInThrow_withCascade() {
     ParserTestCase.parse5("parseThrowExpression", "throw;", [ParserErrorCode.MISSING_EXPRESSION_IN_THROW]);
   }
   void fail_missingExpressionInThrow_withoutCascade() {
     ParserTestCase.parse5("parseThrowExpressionWithoutCascade", "throw;", [ParserErrorCode.MISSING_EXPRESSION_IN_THROW]);
   }
   void fail_missingFunctionParameters_local_nonVoid_block() {
     ParserTestCase.parse5("parseStatement", "int f { return x;}", [ParserErrorCode.MISSING_FUNCTION_PARAMETERS]);
   }
   void fail_missingFunctionParameters_local_nonVoid_expression() {
     ParserTestCase.parse5("parseStatement", "int f => x;", [ParserErrorCode.MISSING_FUNCTION_PARAMETERS]);
   }
+  void fail_namedFunctionExpression() {
+    Expression expression = ParserTestCase.parse5("parsePrimaryExpression", "f() {}", [ParserErrorCode.NAMED_FUNCTION_EXPRESSION]);
+    EngineTestCase.assertInstanceOf(FunctionExpression, expression);
+  }
   void fail_unexpectedToken_invalidPostfixExpression() {
     ParserTestCase.parse5("parseExpression", "f()++", [ParserErrorCode.UNEXPECTED_TOKEN]);
   }
   void fail_voidVariable_initializer() {
     ParserTestCase.parse5("parseStatement", "void x = 0;", [ParserErrorCode.VOID_VARIABLE]);
   }
   void fail_voidVariable_noInitializer() {
     ParserTestCase.parse5("parseStatement", "void x;", [ParserErrorCode.VOID_VARIABLE]);
   }
   void test_abstractClassMember_constructor() {
@@ skipping 117 matching lines @@
   }
   void test_duplicatedModifier_var() {
     ParserTestCase.parse4("parseClassMember", <Object> ["C"], "var var m;", [ParserErrorCode.DUPLICATED_MODIFIER]);
   }
   void test_duplicateLabelInSwitchStatement() {
     ParserTestCase.parse5("parseSwitchStatement", "switch (e) {l1: case 0: break; l1: case 1: break;}", [ParserErrorCode.DUPLICATE_LABEL_IN_SWITCH_STATEMENT]);
   }
   void test_expectedCaseOrDefault() {
     ParserTestCase.parse5("parseSwitchStatement", "switch (e) {break;}", [ParserErrorCode.EXPECTED_CASE_OR_DEFAULT]);
   }
+  void test_expectedClassMember_inClass_afterType() {
+    ParserTestCase.parse4("parseClassMember", <Object> ["C"], "heart 2 heart", [ParserErrorCode.EXPECTED_CLASS_MEMBER]);
+  }
+  void test_expectedClassMember_inClass_beforeType() {
+    ParserTestCase.parse4("parseClassMember", <Object> ["C"], "4 score", [ParserErrorCode.EXPECTED_CLASS_MEMBER]);
+  }
+  void test_expectedExecutable_inClass_afterVoid() {
+    ParserTestCase.parse4("parseClassMember", <Object> ["C"], "void 2 void", [ParserErrorCode.EXPECTED_EXECUTABLE]);
+  }
+  void test_expectedExecutable_topLevel_afterType() {
+    ParserTestCase.parse4("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "heart 2 heart", [ParserErrorCode.EXPECTED_EXECUTABLE]);
+  }
+  void test_expectedExecutable_topLevel_afterVoid() {
+    ParserTestCase.parse4("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "void 2 void", [ParserErrorCode.EXPECTED_EXECUTABLE]);
+  }
+  void test_expectedExecutable_topLevel_beforeType() {
+    ParserTestCase.parse4("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "4 score", [ParserErrorCode.EXPECTED_EXECUTABLE]);
+  }
   void test_expectedStringLiteral() {
     StringLiteral expression = ParserTestCase.parse5("parseStringLiteral", "1", [ParserErrorCode.EXPECTED_STRING_LITERAL]);
     JUnitTestCase.assertTrue(expression.isSynthetic());
   }
   void test_expectedToken_commaMissingInArgumentList() {
     ParserTestCase.parse5("parseArgumentList", "(x, y z)", [ParserErrorCode.EXPECTED_TOKEN]);
   }
   void test_expectedToken_semicolonMissingAfterExpression() {
     ParserTestCase.parse5("parseStatement", "x", [ParserErrorCode.EXPECTED_TOKEN]);
   }
@@ skipping 95 matching lines @@
   }
   void test_invalidCodePoint() {
     ParserTestCase.parse5("parseStringLiteral", "'\\uD900'", [ParserErrorCode.INVALID_CODE_POINT]);
   }
   void test_invalidHexEscape_invalidDigit() {
     ParserTestCase.parse5("parseStringLiteral", "'\\x0 a'", [ParserErrorCode.INVALID_HEX_ESCAPE]);
   }
   void test_invalidHexEscape_tooFewDigits() {
     ParserTestCase.parse5("parseStringLiteral", "'\\x0'", [ParserErrorCode.INVALID_HEX_ESCAPE]);
   }
+  void test_invalidOperator() {
+    ParserTestCase.parse4("parseClassMember", <Object> ["C"], "void operator ===(x) {}", [ParserErrorCode.INVALID_OPERATOR]);
+  }
   void test_invalidOperatorForSuper() {
     ParserTestCase.parse5("parseUnaryExpression", "++super", [ParserErrorCode.INVALID_OPERATOR_FOR_SUPER]);
   }
   void test_invalidUnicodeEscape_incomplete_noDigits() {
     ParserTestCase.parse5("parseStringLiteral", "'\\u{'", [ParserErrorCode.INVALID_UNICODE_ESCAPE]);
   }
   void test_invalidUnicodeEscape_incomplete_someDigits() {
     ParserTestCase.parse5("parseStringLiteral", "'\\u{0A'", [ParserErrorCode.INVALID_UNICODE_ESCAPE]);
   }
   void test_invalidUnicodeEscape_invalidDigit() {
@@ skipping 65 matching lines @@
   void test_missingFunctionParameters_topLevel_void_expression() {
     ParserTestCase.parse5("parseCompilationUnit", "void f => x;", [ParserErrorCode.MISSING_FUNCTION_PARAMETERS]);
   }
   void test_missingIdentifier_functionDeclaration_returnTypeWithoutName() {
     ParserTestCase.parse5("parseFunctionDeclarationStatement", "A<T> () {}", [ParserErrorCode.MISSING_IDENTIFIER]);
   }
   void test_missingIdentifier_number() {
     SimpleIdentifier expression = ParserTestCase.parse5("parseSimpleIdentifier", "1", [ParserErrorCode.MISSING_IDENTIFIER]);
     JUnitTestCase.assertTrue(expression.isSynthetic());
   }
+  void test_missingKeywordOperator() {
+    ParserTestCase.parse4("parseOperator", <Object> [emptyCommentAndMetadata(), null, null], "+(x) {}", [ParserErrorCode.MISSING_KEYWORD_OPERATOR]);
+  }
   void test_missingNameInLibraryDirective() {
     CompilationUnit unit = ParserTestCase.parse5("parseCompilationUnit", "library;", [ParserErrorCode.MISSING_NAME_IN_LIBRARY_DIRECTIVE]);
     JUnitTestCase.assertNotNull(unit);
   }
   void test_missingNameInPartOfDirective() {
     CompilationUnit unit = ParserTestCase.parse5("parseCompilationUnit", "part of;", [ParserErrorCode.MISSING_NAME_IN_PART_OF_DIRECTIVE]);
     JUnitTestCase.assertNotNull(unit);
   }
   void test_missingTerminatorForParameterGroup_named() {
     ParserTestCase.parse5("parseFormalParameterList", "(a, {b: 0)", [ParserErrorCode.MISSING_TERMINATOR_FOR_PARAMETER_GROUP]);
@@ skipping 86 matching lines @@
   }
   void test_staticTopLevelDeclaration_class() {
     ParserTestCase.parse5("parseCompilationUnit", "static class C {}", [ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION]);
   }
   void test_staticTopLevelDeclaration_typedef() {
     ParserTestCase.parse5("parseCompilationUnit", "static typedef F();", [ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION]);
   }
   void test_staticTopLevelDeclaration_variable() {
     ParserTestCase.parse5("parseCompilationUnit", "static var x;", [ParserErrorCode.STATIC_TOP_LEVEL_DECLARATION]);
   }
+  void test_topLevelOperator_withoutType() {
+    ParserTestCase.parse4("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "operator +(bool x, bool y) => x | y;", [ParserErrorCode.TOP_LEVEL_OPERATOR]);
+  }
+  void test_topLevelOperator_withType() {
+    ParserTestCase.parse4("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "bool operator +(bool x, bool y) => x | y;", [ParserErrorCode.TOP_LEVEL_OPERATOR]);
+  }
+  void test_topLevelOperator_withVoid() {
+    ParserTestCase.parse4("parseCompilationUnitMember", <Object> [emptyCommentAndMetadata()], "void operator +(bool x, bool y) => x | y;", [ParserErrorCode.TOP_LEVEL_OPERATOR]);
+  }
   void test_unexpectedTerminatorForParameterGroup_named() {
     ParserTestCase.parse5("parseFormalParameterList", "(a, b})", [ParserErrorCode.UNEXPECTED_TERMINATOR_FOR_PARAMETER_GROUP]);
   }
   void test_unexpectedTerminatorForParameterGroup_optional() {
     ParserTestCase.parse5("parseFormalParameterList", "(a, b])", [ParserErrorCode.UNEXPECTED_TERMINATOR_FOR_PARAMETER_GROUP]);
   }
   void test_unexpectedToken_semicolonBetweenClassMembers() {
     ParserTestCase.parse4("parseClassDeclaration", <Object> [emptyCommentAndMetadata(), null], "class C { int x; ; int y;}", [ParserErrorCode.UNEXPECTED_TOKEN]);
   }
   void test_unexpectedToken_semicolonBetweenCompilationUnitMembers() {
@@ skipping 204 matching lines @@
         runJUnitTest(__test, __test.test_duplicatedModifier_static);
       });
       _ut.test('test_duplicatedModifier_var', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_duplicatedModifier_var);
       });
       _ut.test('test_expectedCaseOrDefault', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedCaseOrDefault);
       });
+      _ut.test('test_expectedClassMember_inClass_afterType', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_expectedClassMember_inClass_afterType);
+      });
+      _ut.test('test_expectedClassMember_inClass_beforeType', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_expectedClassMember_inClass_beforeType);
+      });
+      _ut.test('test_expectedExecutable_inClass_afterVoid', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_expectedExecutable_inClass_afterVoid);
+      });
+      _ut.test('test_expectedExecutable_topLevel_afterType', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_expectedExecutable_topLevel_afterType);
+      });
+      _ut.test('test_expectedExecutable_topLevel_afterVoid', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_expectedExecutable_topLevel_afterVoid);
+      });
+      _ut.test('test_expectedExecutable_topLevel_beforeType', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_expectedExecutable_topLevel_beforeType);
+      });
       _ut.test('test_expectedStringLiteral', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedStringLiteral);
       });
       _ut.test('test_expectedToken_commaMissingInArgumentList', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_expectedToken_commaMissingInArgumentList);
       });
       _ut.test('test_expectedToken_semicolonMissingAfterExpression', () {
         final __test = new ErrorParserTest();
@@ skipping 132 matching lines @@
         runJUnitTest(__test, __test.test_invalidCodePoint);
       });
       _ut.test('test_invalidHexEscape_invalidDigit', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_invalidHexEscape_invalidDigit);
       });
       _ut.test('test_invalidHexEscape_tooFewDigits', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_invalidHexEscape_tooFewDigits);
       });
+      _ut.test('test_invalidOperator', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_invalidOperator);
+      });
       _ut.test('test_invalidOperatorForSuper', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_invalidOperatorForSuper);
       });
       _ut.test('test_invalidUnicodeEscape_incomplete_noDigits', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_invalidUnicodeEscape_incomplete_noDigits);
       });
       _ut.test('test_invalidUnicodeEscape_incomplete_someDigits', () {
         final __test = new ErrorParserTest();
@@ skipping 88 matching lines @@
         runJUnitTest(__test, __test.test_missingFunctionParameters_topLevel_void_expression);
       });
       _ut.test('test_missingIdentifier_functionDeclaration_returnTypeWithoutName', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingIdentifier_functionDeclaration_returnTypeWithoutName);
       });
       _ut.test('test_missingIdentifier_number', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingIdentifier_number);
       });
+      _ut.test('test_missingKeywordOperator', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_missingKeywordOperator);
+      });
       _ut.test('test_missingNameInLibraryDirective', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingNameInLibraryDirective);
       });
       _ut.test('test_missingNameInPartOfDirective', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_missingNameInPartOfDirective);
       });
       _ut.test('test_missingTerminatorForParameterGroup_named', () {
         final __test = new ErrorParserTest();
@@ skipping 116 matching lines @@
         runJUnitTest(__test, __test.test_staticTopLevelDeclaration_class);
       });
       _ut.test('test_staticTopLevelDeclaration_typedef', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_staticTopLevelDeclaration_typedef);
       });
       _ut.test('test_staticTopLevelDeclaration_variable', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_staticTopLevelDeclaration_variable);
       });
+      _ut.test('test_topLevelOperator_withType', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_topLevelOperator_withType);
+      });
+      _ut.test('test_topLevelOperator_withVoid', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_topLevelOperator_withVoid);
+      });
+      _ut.test('test_topLevelOperator_withoutType', () {
+        final __test = new ErrorParserTest();
+        runJUnitTest(__test, __test.test_topLevelOperator_withoutType);
+      });
       _ut.test('test_unexpectedTerminatorForParameterGroup_named', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_unexpectedTerminatorForParameterGroup_named);
       });
       _ut.test('test_unexpectedTerminatorForParameterGroup_optional', () {
         final __test = new ErrorParserTest();
         runJUnitTest(__test, __test.test_unexpectedTerminatorForParameterGroup_optional);
       });
       _ut.test('test_unexpectedToken_semicolonBetweenClassMembers', () {
         final __test = new ErrorParserTest();
@@ skipping 79 matching lines @@
   'createSyntheticIdentifier_0': new MethodTrampoline(0, (Parser target) => target.createSyntheticIdentifier()),
   'createSyntheticStringLiteral_0': new MethodTrampoline(0, (Parser target) => target.createSyntheticStringLiteral()),
   'createSyntheticToken_1': new MethodTrampoline(1, (Parser target, arg0) => target.createSyntheticToken(arg0)),
   'ensureAssignable_1': new MethodTrampoline(1, (Parser target, arg0) => target.ensureAssignable(arg0)),
   'expect_1': new MethodTrampoline(1, (Parser target, arg0) => target.expect(arg0)),
   'hasReturnTypeInTypeAlias_0': new MethodTrampoline(0, (Parser target) => target.hasReturnTypeInTypeAlias()),
   'isFunctionDeclaration_0': new MethodTrampoline(0, (Parser target) => target.isFunctionDeclaration()),
   'isFunctionExpression_1': new MethodTrampoline(1, (Parser target, arg0) => target.isFunctionExpression(arg0)),
   'isHexDigit_1': new MethodTrampoline(1, (Parser target, arg0) => target.isHexDigit(arg0)),
   'isInitializedVariableDeclaration_0': new MethodTrampoline(0, (Parser target) => target.isInitializedVariableDeclaration()),
+  'isOperator_1': new MethodTrampoline(1, (Parser target, arg0) => target.isOperator(arg0)),
   'isSwitchMember_0': new MethodTrampoline(0, (Parser target) => target.isSwitchMember()),
   'lexicallyFirst_1': new MethodTrampoline(1, (Parser target, arg0) => target.lexicallyFirst(arg0)),
   'matches_1': new MethodTrampoline(1, (Parser target, arg0) => target.matches(arg0)),
   'matches_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.matches3(arg0, arg1)),
   'matchesAny_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.matchesAny(arg0, arg1)),
   'matchesIdentifier_0': new MethodTrampoline(0, (Parser target) => target.matchesIdentifier()),
   'matchesIdentifier_1': new MethodTrampoline(1, (Parser target, arg0) => target.matchesIdentifier2(arg0)),
   'optional_1': new MethodTrampoline(1, (Parser target, arg0) => target.optional(arg0)),
   'parseAdditiveExpression_0': new MethodTrampoline(0, (Parser target) => target.parseAdditiveExpression()),
   'parseAnnotation_0': new MethodTrampoline(0, (Parser target) => target.parseAnnotation()),
@@ skipping 94 matching lines @@
   'parseTypeAlias_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseTypeAlias(arg0)),
   'parseTypeArgumentList_0': new MethodTrampoline(0, (Parser target) => target.parseTypeArgumentList()),
   'parseTypeName_0': new MethodTrampoline(0, (Parser target) => target.parseTypeName()),
   'parseTypeParameter_0': new MethodTrampoline(0, (Parser target) => target.parseTypeParameter()),
   'parseTypeParameterList_0': new MethodTrampoline(0, (Parser target) => target.parseTypeParameterList()),
   'parseUnaryExpression_0': new MethodTrampoline(0, (Parser target) => target.parseUnaryExpression()),
   'parseVariableDeclaration_0': new MethodTrampoline(0, (Parser target) => target.parseVariableDeclaration()),
   'parseVariableDeclarationList_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseVariableDeclarationList(arg0)),
   'parseVariableDeclarationList_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target.parseVariableDeclarationList2(arg0, arg1, arg2)),
   'parseVariableDeclarationStatement_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseVariableDeclarationStatement(arg0)),
+  'parseVariableDeclarationStatement_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target.parseVariableDeclarationStatement2(arg0, arg1, arg2)),
   'parseWhileStatement_0': new MethodTrampoline(0, (Parser target) => target.parseWhileStatement()),
   'parseWithClause_0': new MethodTrampoline(0, (Parser target) => target.parseWithClause()),
   'peek_0': new MethodTrampoline(0, (Parser target) => target.peek()),
   'peek_1': new MethodTrampoline(1, (Parser target, arg0) => target.peek2(arg0)),
   'reportError_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target.reportError(arg0, arg1, arg2)),
   'reportError_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.reportError4(arg0, arg1)),
   'skipFinalConstVarOrType_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipFinalConstVarOrType(arg0)),
   'skipFormalParameterList_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipFormalParameterList(arg0)),
   'skipPastMatchingToken_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipPastMatchingToken(arg0)),
   'skipPrefixedIdentifier_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipPrefixedIdentifier(arg0)),
@@ skipping 15 matching lines @@
   'validateModifiersForTopLevelFunction_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForTopLevelFunction(arg0)),
   'validateModifiersForTopLevelVariable_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForTopLevelVariable(arg0)),
   'validateModifiersForTypedef_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForTypedef(arg0)),};
 
 
 Object invokeParserMethodImpl(Parser parser, String methodName, List<Object> objects, Token tokenStream) {
   parser.currentToken = tokenStream;
   MethodTrampoline method = _methodTable_Parser['${methodName}_${objects.length}'];
   return method.invoke(parser, objects);
 }