New analzyer snapshot.

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.
 
 // 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 'package:analyzer/src/generated/java_core.dart';
@@ skipping 16 matching lines @@
  * code fragments should be as minimal as possible in order to test the method, but should not test
  * the interactions between the method under test and other methods.
  *
  * More complex tests should be defined in the class [ComplexParserTest].
  */
 class SimpleParserTest extends ParserTestCase {
   void fail_parseCommentReference_this() {
     // This fails because we are returning null from the method and asserting that the return value
     // is not null.
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["this", 5], "");
-    SimpleIdentifier identifier = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
+    SimpleIdentifier identifier = EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, reference.identifier);
     JUnitTestCase.assertNotNull(identifier.token);
     JUnitTestCase.assertEquals("a", identifier.name);
     JUnitTestCase.assertEquals(5, identifier.offset);
   }
 
   void test_computeStringValue_emptyInterpolationPrefix() {
     JUnitTestCase.assertEquals("", computeStringValue("'''", true, false));
   }
 
   void test_computeStringValue_escape_b() {
@@ skipping 250 matching lines @@
   void test_parseAdditiveExpression_normal() {
     BinaryExpression expression = ParserTestCase.parse4("parseAdditiveExpression", "x + y", []);
     JUnitTestCase.assertNotNull(expression.leftOperand);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.PLUS, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.rightOperand);
   }
 
   void test_parseAdditiveExpression_super() {
     BinaryExpression expression = ParserTestCase.parse4("parseAdditiveExpression", "super + y", []);
-    EngineTestCase.assertInstanceOf(SuperExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SuperExpression, SuperExpression, expression.leftOperand);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.PLUS, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.rightOperand);
   }
 
   void test_parseAnnotation_n1() {
     Annotation annotation = ParserTestCase.parse4("parseAnnotation", "@A", []);
     JUnitTestCase.assertNotNull(annotation.atSign);
     JUnitTestCase.assertNotNull(annotation.name);
     JUnitTestCase.assertNull(annotation.period);
@@ skipping 152 matching lines @@
   void test_parseAssignableExpression_identifier_index() {
     IndexExpression expression = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "x[y]");
     JUnitTestCase.assertNotNull(expression.target);
     JUnitTestCase.assertNotNull(expression.leftBracket);
     JUnitTestCase.assertNotNull(expression.index);
     JUnitTestCase.assertNotNull(expression.rightBracket);
   }
 
   void test_parseAssignableExpression_super_dot() {
     PropertyAccess propertyAccess = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "super.y");
-    EngineTestCase.assertInstanceOf(SuperExpression, propertyAccess.target);
+    EngineTestCase.assertInstanceOf((obj) => obj is SuperExpression, SuperExpression, propertyAccess.target);
     JUnitTestCase.assertNotNull(propertyAccess.operator);
     JUnitTestCase.assertNotNull(propertyAccess.propertyName);
   }
 
   void test_parseAssignableExpression_super_index() {
     IndexExpression expression = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "super[y]");
-    EngineTestCase.assertInstanceOf(SuperExpression, expression.target);
+    EngineTestCase.assertInstanceOf((obj) => obj is SuperExpression, SuperExpression, expression.target);
     JUnitTestCase.assertNotNull(expression.leftBracket);
     JUnitTestCase.assertNotNull(expression.index);
     JUnitTestCase.assertNotNull(expression.rightBracket);
   }
 
   void test_parseAssignableSelector_dot() {
     PropertyAccess selector = ParserTestCase.parse("parseAssignableSelector", <Object> [null, true], ".x");
     JUnitTestCase.assertNotNull(selector.operator);
     JUnitTestCase.assertNotNull(selector.propertyName);
   }
@@ skipping 13 matching lines @@
   void test_parseBitwiseAndExpression_normal() {
     BinaryExpression expression = ParserTestCase.parse4("parseBitwiseAndExpression", "x & y", []);
     JUnitTestCase.assertNotNull(expression.leftOperand);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.AMPERSAND, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.rightOperand);
   }
 
   void test_parseBitwiseAndExpression_super() {
     BinaryExpression expression = ParserTestCase.parse4("parseBitwiseAndExpression", "super & y", []);
-    EngineTestCase.assertInstanceOf(SuperExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SuperExpression, SuperExpression, expression.leftOperand);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.AMPERSAND, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.rightOperand);
   }
 
   void test_parseBitwiseOrExpression_normal() {
     BinaryExpression expression = ParserTestCase.parse4("parseBitwiseOrExpression", "x | y", []);
     JUnitTestCase.assertNotNull(expression.leftOperand);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.BAR, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.rightOperand);
   }
 
   void test_parseBitwiseOrExpression_super() {
     BinaryExpression expression = ParserTestCase.parse4("parseBitwiseOrExpression", "super | y", []);
-    EngineTestCase.assertInstanceOf(SuperExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SuperExpression, SuperExpression, expression.leftOperand);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.BAR, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.rightOperand);
   }
 
   void test_parseBitwiseXorExpression_normal() {
     BinaryExpression expression = ParserTestCase.parse4("parseBitwiseXorExpression", "x ^ y", []);
     JUnitTestCase.assertNotNull(expression.leftOperand);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.CARET, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.rightOperand);
   }
 
   void test_parseBitwiseXorExpression_super() {
     BinaryExpression expression = ParserTestCase.parse4("parseBitwiseXorExpression", "super ^ y", []);
-    EngineTestCase.assertInstanceOf(SuperExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SuperExpression, SuperExpression, expression.leftOperand);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.CARET, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.rightOperand);
   }
 
   void test_parseBlock_empty() {
     Block block = ParserTestCase.parse4("parseBlock", "{}", []);
     JUnitTestCase.assertNotNull(block.leftBracket);
     EngineTestCase.assertSize(0, block.statements);
     JUnitTestCase.assertNotNull(block.rightBracket);
@@ skipping 23 matching lines @@
   void test_parseCascadeSection_i() {
     IndexExpression section = ParserTestCase.parse4("parseCascadeSection", "..[i]", []);
     JUnitTestCase.assertNull(section.target);
     JUnitTestCase.assertNotNull(section.leftBracket);
     JUnitTestCase.assertNotNull(section.index);
     JUnitTestCase.assertNotNull(section.rightBracket);
   }
 
   void test_parseCascadeSection_ia() {
     FunctionExpressionInvocation section = ParserTestCase.parse4("parseCascadeSection", "..[i](b)", []);
-    EngineTestCase.assertInstanceOf(IndexExpression, section.function);
+    EngineTestCase.assertInstanceOf((obj) => obj is IndexExpression, IndexExpression, section.function);
     JUnitTestCase.assertNotNull(section.argumentList);
   }
 
   void test_parseCascadeSection_ii() {
     MethodInvocation section = ParserTestCase.parse4("parseCascadeSection", "..a(b).c(d)", []);
-    EngineTestCase.assertInstanceOf(MethodInvocation, section.target);
+    EngineTestCase.assertInstanceOf((obj) => obj is MethodInvocation, MethodInvocation, section.target);
     JUnitTestCase.assertNotNull(section.period);
     JUnitTestCase.assertNotNull(section.methodName);
     JUnitTestCase.assertNotNull(section.argumentList);
     EngineTestCase.assertSize(1, section.argumentList.arguments);
   }
 
   void test_parseCascadeSection_p() {
     PropertyAccess section = ParserTestCase.parse4("parseCascadeSection", "..a", []);
     JUnitTestCase.assertNull(section.target);
     JUnitTestCase.assertNotNull(section.operator);
     JUnitTestCase.assertNotNull(section.propertyName);
   }
 
   void test_parseCascadeSection_p_assign() {
     AssignmentExpression section = ParserTestCase.parse4("parseCascadeSection", "..a = 3", []);
     JUnitTestCase.assertNotNull(section.leftHandSide);
     JUnitTestCase.assertNotNull(section.operator);
     Expression rhs = section.rightHandSide;
     JUnitTestCase.assertNotNull(rhs);
   }
 
   void test_parseCascadeSection_p_assign_withCascade() {
     AssignmentExpression section = ParserTestCase.parse4("parseCascadeSection", "..a = 3..m()", []);
     JUnitTestCase.assertNotNull(section.leftHandSide);
     JUnitTestCase.assertNotNull(section.operator);
     Expression rhs = section.rightHandSide;
-    EngineTestCase.assertInstanceOf(IntegerLiteral, rhs);
+    EngineTestCase.assertInstanceOf((obj) => obj is IntegerLiteral, IntegerLiteral, rhs);
   }
 
   void test_parseCascadeSection_p_builtIn() {
     PropertyAccess section = ParserTestCase.parse4("parseCascadeSection", "..as", []);
     JUnitTestCase.assertNull(section.target);
     JUnitTestCase.assertNotNull(section.operator);
     JUnitTestCase.assertNotNull(section.propertyName);
   }
 
   void test_parseCascadeSection_pa() {
     MethodInvocation section = ParserTestCase.parse4("parseCascadeSection", "..a(b)", []);
     JUnitTestCase.assertNull(section.target);
     JUnitTestCase.assertNotNull(section.period);
     JUnitTestCase.assertNotNull(section.methodName);
     JUnitTestCase.assertNotNull(section.argumentList);
     EngineTestCase.assertSize(1, section.argumentList.arguments);
   }
 
   void test_parseCascadeSection_paa() {
     FunctionExpressionInvocation section = ParserTestCase.parse4("parseCascadeSection", "..a(b)(c)", []);
-    EngineTestCase.assertInstanceOf(MethodInvocation, section.function);
+    EngineTestCase.assertInstanceOf((obj) => obj is MethodInvocation, MethodInvocation, section.function);
     JUnitTestCase.assertNotNull(section.argumentList);
     EngineTestCase.assertSize(1, section.argumentList.arguments);
   }
 
   void test_parseCascadeSection_paapaa() {
     FunctionExpressionInvocation section = ParserTestCase.parse4("parseCascadeSection", "..a(b)(c).d(e)(f)", []);
-    EngineTestCase.assertInstanceOf(MethodInvocation, section.function);
+    EngineTestCase.assertInstanceOf((obj) => obj is MethodInvocation, MethodInvocation, section.function);
     JUnitTestCase.assertNotNull(section.argumentList);
     EngineTestCase.assertSize(1, section.argumentList.arguments);
   }
 
   void test_parseCascadeSection_pap() {
     PropertyAccess section = ParserTestCase.parse4("parseCascadeSection", "..a(b).c", []);
     JUnitTestCase.assertNotNull(section.target);
     JUnitTestCase.assertNotNull(section.operator);
     JUnitTestCase.assertNotNull(section.propertyName);
   }
@@ skipping 624 matching lines @@
   }
 
   void test_parseCommentAndMetadata_singleLine() {
     CommentAndMetadata commentAndMetadata = ParserTestCase.parse4("parseCommentAndMetadata", EngineTestCase.createSource(["/// 1", "/// 2", "void"]), []);
     JUnitTestCase.assertNotNull(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);
+    PrefixedIdentifier prefixedIdentifier = EngineTestCase.assertInstanceOf((obj) => obj is PrefixedIdentifier, PrefixedIdentifier, reference.identifier);
     SimpleIdentifier prefix = prefixedIdentifier.prefix;
     JUnitTestCase.assertNotNull(prefix.token);
     JUnitTestCase.assertEquals("a", prefix.name);
     JUnitTestCase.assertEquals(11, prefix.offset);
     JUnitTestCase.assertNotNull(prefixedIdentifier.period);
     SimpleIdentifier identifier = prefixedIdentifier.identifier;
     JUnitTestCase.assertNotNull(identifier.token);
     JUnitTestCase.assertEquals("b", identifier.name);
     JUnitTestCase.assertEquals(13, identifier.offset);
   }
 
   void test_parseCommentReference_new_simple() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["new a", 5], "");
-    SimpleIdentifier identifier = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
+    SimpleIdentifier identifier = EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, reference.identifier);
     JUnitTestCase.assertNotNull(identifier.token);
     JUnitTestCase.assertEquals("a", identifier.name);
     JUnitTestCase.assertEquals(9, identifier.offset);
   }
 
   void test_parseCommentReference_prefixed() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["a.b", 7], "");
-    PrefixedIdentifier prefixedIdentifier = EngineTestCase.assertInstanceOf(PrefixedIdentifier, reference.identifier);
+    PrefixedIdentifier prefixedIdentifier = EngineTestCase.assertInstanceOf((obj) => obj is PrefixedIdentifier, PrefixedIdentifier, reference.identifier);
     SimpleIdentifier prefix = prefixedIdentifier.prefix;
     JUnitTestCase.assertNotNull(prefix.token);
     JUnitTestCase.assertEquals("a", prefix.name);
     JUnitTestCase.assertEquals(7, prefix.offset);
     JUnitTestCase.assertNotNull(prefixedIdentifier.period);
     SimpleIdentifier identifier = prefixedIdentifier.identifier;
     JUnitTestCase.assertNotNull(identifier.token);
     JUnitTestCase.assertEquals("b", identifier.name);
     JUnitTestCase.assertEquals(9, identifier.offset);
   }
 
   void test_parseCommentReference_simple() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["a", 5], "");
-    SimpleIdentifier identifier = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
+    SimpleIdentifier identifier = EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, reference.identifier);
     JUnitTestCase.assertNotNull(identifier.token);
     JUnitTestCase.assertEquals("a", identifier.name);
     JUnitTestCase.assertEquals(5, identifier.offset);
   }
 
   void test_parseCommentReference_synthetic() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["", 5], "");
-    SimpleIdentifier identifier = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
+    SimpleIdentifier identifier = EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, reference.identifier);
     JUnitTestCase.assertNotNull(identifier);
     JUnitTestCase.assertTrue(identifier.isSynthetic);
     JUnitTestCase.assertNotNull(identifier.token);
     JUnitTestCase.assertEquals("", identifier.name);
     JUnitTestCase.assertEquals(5, identifier.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], "");
@@ skipping 587 matching lines @@
   void test_parseEqualityExpression_normal() {
     BinaryExpression expression = ParserTestCase.parse4("parseEqualityExpression", "x == y", []);
     JUnitTestCase.assertNotNull(expression.leftOperand);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.EQ_EQ, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.rightOperand);
   }
 
   void test_parseEqualityExpression_super() {
     BinaryExpression expression = ParserTestCase.parse4("parseEqualityExpression", "super == y", []);
-    EngineTestCase.assertInstanceOf(SuperExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SuperExpression, SuperExpression, expression.leftOperand);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.EQ_EQ, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.rightOperand);
   }
 
   void test_parseExportDirective_hide() {
     ExportDirective directive = ParserTestCase.parse("parseExportDirective", <Object> [emptyCommentAndMetadata()], "export 'lib/lib.dart' hide A, B;");
     JUnitTestCase.assertNotNull(directive.keyword);
     JUnitTestCase.assertNotNull(directive.uri);
     EngineTestCase.assertSize(1, directive.combinators);
@@ skipping 44 matching lines @@
   void test_parseExpression_comparison() {
     BinaryExpression expression = ParserTestCase.parse4("parseExpression", "--a.b == c", []);
     JUnitTestCase.assertNotNull(expression.leftOperand);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.EQ_EQ, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.rightOperand);
   }
 
   void test_parseExpression_invokeFunctionExpression() {
     FunctionExpressionInvocation invocation = ParserTestCase.parse4("parseExpression", "(a) {return a + a;} (3)", []);
-    EngineTestCase.assertInstanceOf(FunctionExpression, invocation.function);
+    EngineTestCase.assertInstanceOf((obj) => obj is FunctionExpression, FunctionExpression, invocation.function);
     FunctionExpression expression = invocation.function as FunctionExpression;
     JUnitTestCase.assertNotNull(expression.parameters);
     JUnitTestCase.assertNotNull(expression.body);
     ArgumentList list = invocation.argumentList;
     JUnitTestCase.assertNotNull(list);
     EngineTestCase.assertSize(1, list.arguments);
   }
 
   void test_parseExpression_superMethodInvocation() {
     MethodInvocation invocation = ParserTestCase.parse4("parseExpression", "super.m()", []);
@@ skipping 33 matching lines @@
     MethodInvocation invocation = ParserTestCase.parse4("parseExpressionWithoutCascade", "super.m()", []);
     JUnitTestCase.assertNotNull(invocation.target);
     JUnitTestCase.assertNotNull(invocation.methodName);
     JUnitTestCase.assertNotNull(invocation.argumentList);
   }
 
   void test_parseExtendsClause() {
     ExtendsClause clause = ParserTestCase.parse4("parseExtendsClause", "extends B", []);
     JUnitTestCase.assertNotNull(clause.keyword);
     JUnitTestCase.assertNotNull(clause.superclass);
-    EngineTestCase.assertInstanceOf(TypeName, clause.superclass);
+    EngineTestCase.assertInstanceOf((obj) => obj is TypeName, TypeName, clause.superclass);
   }
 
   void test_parseFinalConstVarOrType_const_noType() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "const");
     Token keyword = result.keyword;
     JUnitTestCase.assertNotNull(keyword);
     JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword.type);
     JUnitTestCase.assertEquals(Keyword.CONST, (keyword as KeywordToken).keyword);
     JUnitTestCase.assertNull(result.type);
   }
@@ skipping 476 matching lines @@
   void test_parseFunctionBody_nativeFunctionBody() {
     NativeFunctionBody functionBody = ParserTestCase.parse("parseFunctionBody", <Object> [false, null, false], "native 'str';");
     JUnitTestCase.assertNotNull(functionBody.nativeToken);
     JUnitTestCase.assertNotNull(functionBody.stringLiteral);
     JUnitTestCase.assertNotNull(functionBody.semicolon);
   }
 
   void test_parseFunctionBody_skip_block() {
     ParserTestCase._parseFunctionBodies = false;
     FunctionBody functionBody = ParserTestCase.parse("parseFunctionBody", <Object> [false, null, false], "{}");
-    EngineTestCase.assertInstanceOf(EmptyFunctionBody, functionBody);
+    EngineTestCase.assertInstanceOf((obj) => obj is EmptyFunctionBody, EmptyFunctionBody, functionBody);
   }
 
   void test_parseFunctionBody_skip_blocks() {
     ParserTestCase._parseFunctionBodies = false;
     FunctionBody functionBody = ParserTestCase.parse("parseFunctionBody", <Object> [false, null, false], "{ {} }");
-    EngineTestCase.assertInstanceOf(EmptyFunctionBody, functionBody);
+    EngineTestCase.assertInstanceOf((obj) => obj is EmptyFunctionBody, EmptyFunctionBody, functionBody);
   }
 
   void test_parseFunctionBody_skip_expression() {
     ParserTestCase._parseFunctionBodies = false;
     FunctionBody functionBody = ParserTestCase.parse("parseFunctionBody", <Object> [false, null, false], "=> y;");
-    EngineTestCase.assertInstanceOf(EmptyFunctionBody, functionBody);
+    EngineTestCase.assertInstanceOf((obj) => obj is EmptyFunctionBody, EmptyFunctionBody, functionBody);
   }
 
   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() {}");
     JUnitTestCase.assertEquals(comment, declaration.documentationComment);
     JUnitTestCase.assertEquals(returnType, declaration.returnType);
     JUnitTestCase.assertNotNull(declaration.name);
     FunctionExpression expression = declaration.functionExpression;
@@ skipping 493 matching lines @@
   void test_parseMultiplicativeExpression_normal() {
     BinaryExpression expression = ParserTestCase.parse4("parseMultiplicativeExpression", "x * y", []);
     JUnitTestCase.assertNotNull(expression.leftOperand);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.STAR, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.rightOperand);
   }
 
   void test_parseMultiplicativeExpression_super() {
     BinaryExpression expression = ParserTestCase.parse4("parseMultiplicativeExpression", "super * y", []);
-    EngineTestCase.assertInstanceOf(SuperExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SuperExpression, SuperExpression, expression.leftOperand);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.STAR, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.rightOperand);
   }
 
   void test_parseNewExpression() {
     InstanceCreationExpression expression = ParserTestCase.parse4("parseNewExpression", "new A()", []);
     JUnitTestCase.assertNotNull(expression.keyword);
     ConstructorName name = expression.constructorName;
     JUnitTestCase.assertNotNull(name);
@@ skipping 56 matching lines @@
     ParserTestCase.parse4("parseNonLabeledStatement", "() {}[0] = null;", []);
   }
 
   void test_parseNonLabeledStatement_functionInvocation() {
     ExpressionStatement statement = ParserTestCase.parse4("parseNonLabeledStatement", "f();", []);
     JUnitTestCase.assertNotNull(statement.expression);
   }
 
   void test_parseNonLabeledStatement_invokeFunctionExpression() {
     ExpressionStatement statement = ParserTestCase.parse4("parseNonLabeledStatement", "(a) {return a + a;} (3);", []);
-    EngineTestCase.assertInstanceOf(FunctionExpressionInvocation, statement.expression);
+    EngineTestCase.assertInstanceOf((obj) => obj is FunctionExpressionInvocation, FunctionExpressionInvocation, statement.expression);
     FunctionExpressionInvocation invocation = statement.expression as FunctionExpressionInvocation;
-    EngineTestCase.assertInstanceOf(FunctionExpression, invocation.function);
+    EngineTestCase.assertInstanceOf((obj) => obj is FunctionExpression, FunctionExpression, invocation.function);
     FunctionExpression expression = invocation.function as FunctionExpression;
     JUnitTestCase.assertNotNull(expression.parameters);
     JUnitTestCase.assertNotNull(expression.body);
     ArgumentList list = invocation.argumentList;
     JUnitTestCase.assertNotNull(list);
     EngineTestCase.assertSize(1, list.arguments);
   }
 
   void test_parseNonLabeledStatement_null() {
     ExpressionStatement statement = ParserTestCase.parse4("parseNonLabeledStatement", "null;", []);
@@ skipping 1047 matching lines @@
     JUnitTestCase.assertNotNull(declaration.initializer);
   }
 
   void test_parseVariableDeclaration_noEquals() {
     VariableDeclaration declaration = ParserTestCase.parse4("parseVariableDeclaration", "a", []);
     JUnitTestCase.assertNotNull(declaration.name);
     JUnitTestCase.assertNull(declaration.equals);
     JUnitTestCase.assertNull(declaration.initializer);
   }
 
-  void test_parseVariableDeclarationList_const_noType() {
-    VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationList", <Object> [emptyCommentAndMetadata()], "const a");
+  void test_parseVariableDeclarationListAfterMetadata_const_noType() {
+    VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationListAfterMetadata", <Object> [emptyCommentAndMetadata()], "const a");
     JUnitTestCase.assertNotNull(declarationList.keyword);
     JUnitTestCase.assertNull(declarationList.type);
     EngineTestCase.assertSize(1, declarationList.variables);
   }
 
-  void test_parseVariableDeclarationList_const_type() {
-    VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationList", <Object> [emptyCommentAndMetadata()], "const A a");
+  void test_parseVariableDeclarationListAfterMetadata_const_type() {
+    VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationListAfterMetadata", <Object> [emptyCommentAndMetadata()], "const A a");
     JUnitTestCase.assertNotNull(declarationList.keyword);
     JUnitTestCase.assertNotNull(declarationList.type);
     EngineTestCase.assertSize(1, declarationList.variables);
   }
 
-  void test_parseVariableDeclarationList_final_noType() {
-    VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationList", <Object> [emptyCommentAndMetadata()], "final a");
+  void test_parseVariableDeclarationListAfterMetadata_final_noType() {
+    VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationListAfterMetadata", <Object> [emptyCommentAndMetadata()], "final a");
     JUnitTestCase.assertNotNull(declarationList.keyword);
     JUnitTestCase.assertNull(declarationList.type);
     EngineTestCase.assertSize(1, declarationList.variables);
   }
 
-  void test_parseVariableDeclarationList_final_type() {
-    VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationList", <Object> [emptyCommentAndMetadata()], "final A a");
+  void test_parseVariableDeclarationListAfterMetadata_final_type() {
+    VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationListAfterMetadata", <Object> [emptyCommentAndMetadata()], "final A a");
     JUnitTestCase.assertNotNull(declarationList.keyword);
     JUnitTestCase.assertNotNull(declarationList.type);
     EngineTestCase.assertSize(1, declarationList.variables);
   }
 
-  void test_parseVariableDeclarationList_type_multiple() {
-    VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationList", <Object> [emptyCommentAndMetadata()], "A a, b, c");
+  void test_parseVariableDeclarationListAfterMetadata_type_multiple() {
+    VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationListAfterMetadata", <Object> [emptyCommentAndMetadata()], "A a, b, c");
     JUnitTestCase.assertNull(declarationList.keyword);
     JUnitTestCase.assertNotNull(declarationList.type);
     EngineTestCase.assertSize(3, declarationList.variables);
   }
 
-  void test_parseVariableDeclarationList_type_single() {
-    VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationList", <Object> [emptyCommentAndMetadata()], "A a");
+  void test_parseVariableDeclarationListAfterMetadata_type_single() {
+    VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationListAfterMetadata", <Object> [emptyCommentAndMetadata()], "A a");
     JUnitTestCase.assertNull(declarationList.keyword);
     JUnitTestCase.assertNotNull(declarationList.type);
     EngineTestCase.assertSize(1, declarationList.variables);
   }
 
-  void test_parseVariableDeclarationList_var_multiple() {
-    VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationList", <Object> [emptyCommentAndMetadata()], "var a, b, c");
+  void test_parseVariableDeclarationListAfterMetadata_var_multiple() {
+    VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationListAfterMetadata", <Object> [emptyCommentAndMetadata()], "var a, b, c");
     JUnitTestCase.assertNotNull(declarationList.keyword);
     JUnitTestCase.assertNull(declarationList.type);
     EngineTestCase.assertSize(3, declarationList.variables);
   }
 
-  void test_parseVariableDeclarationList_var_single() {
-    VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationList", <Object> [emptyCommentAndMetadata()], "var a");
+  void test_parseVariableDeclarationListAfterMetadata_var_single() {
+    VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationListAfterMetadata", <Object> [emptyCommentAndMetadata()], "var a");
     JUnitTestCase.assertNotNull(declarationList.keyword);
     JUnitTestCase.assertNull(declarationList.type);
     EngineTestCase.assertSize(1, declarationList.variables);
   }
 
-  void test_parseVariableDeclarationList2_type() {
+  void test_parseVariableDeclarationListAfterType_type() {
     TypeName type = new TypeName(new SimpleIdentifier(null), null);
-    VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationList", <Object> [emptyCommentAndMetadata(), null, type], "a");
+    VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationListAfterType", <Object> [emptyCommentAndMetadata(), null, type], "a");
     JUnitTestCase.assertNull(declarationList.keyword);
     JUnitTestCase.assertEquals(type, declarationList.type);
     EngineTestCase.assertSize(1, declarationList.variables);
   }
 
-  void test_parseVariableDeclarationList2_var() {
+  void test_parseVariableDeclarationListAfterType_var() {
     Token keyword = TokenFactory.token(Keyword.VAR);
-    VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationList", <Object> [emptyCommentAndMetadata(), keyword, null], "a, b, c");
+    VariableDeclarationList declarationList = ParserTestCase.parse("parseVariableDeclarationListAfterType", <Object> [emptyCommentAndMetadata(), keyword, null], "a, b, c");
     JUnitTestCase.assertEquals(keyword, declarationList.keyword);
     JUnitTestCase.assertNull(declarationList.type);
     EngineTestCase.assertSize(3, declarationList.variables);
   }
 
-  void test_parseVariableDeclarationStatement_multiple() {
-    VariableDeclarationStatement statement = ParserTestCase.parse("parseVariableDeclarationStatement", <Object> [emptyCommentAndMetadata()], "var x, y, z;");
+  void test_parseVariableDeclarationStatementAfterMetadata_multiple() {
+    VariableDeclarationStatement statement = ParserTestCase.parse("parseVariableDeclarationStatementAfterMetadata", <Object> [emptyCommentAndMetadata()], "var x, y, z;");
     JUnitTestCase.assertNotNull(statement.semicolon);
     VariableDeclarationList variableList = statement.variables;
     JUnitTestCase.assertNotNull(variableList);
     EngineTestCase.assertSize(3, variableList.variables);
   }
 
-  void test_parseVariableDeclarationStatement_single() {
-    VariableDeclarationStatement statement = ParserTestCase.parse("parseVariableDeclarationStatement", <Object> [emptyCommentAndMetadata()], "var x;");
+  void test_parseVariableDeclarationStatementAfterMetadata_single() {
+    VariableDeclarationStatement statement = ParserTestCase.parse("parseVariableDeclarationStatementAfterMetadata", <Object> [emptyCommentAndMetadata()], "var x;");
     JUnitTestCase.assertNotNull(statement.semicolon);
     VariableDeclarationList variableList = statement.variables;
     JUnitTestCase.assertNotNull(variableList);
     EngineTestCase.assertSize(1, variableList.variables);
   }
 
   void test_parseWhileStatement() {
     WhileStatement statement = ParserTestCase.parse4("parseWhileStatement", "while (x) {}", []);
     JUnitTestCase.assertNotNull(statement.keyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
@@ skipping 2283 matching lines @@
         runJUnitTest(__test, __test.test_parseUnaryExpression_not_super);
       });
       _ut.test('test_parseUnaryExpression_tilda_normal', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseUnaryExpression_tilda_normal);
       });
       _ut.test('test_parseUnaryExpression_tilda_super', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseUnaryExpression_tilda_super);
       });
-      _ut.test('test_parseVariableDeclarationList2_type', () {
+      _ut.test('test_parseVariableDeclarationListAfterMetadata_const_noType', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseVariableDeclarationList2_type);
+        runJUnitTest(__test, __test.test_parseVariableDeclarationListAfterMetadata_const_noType);
       });
-      _ut.test('test_parseVariableDeclarationList2_var', () {
+      _ut.test('test_parseVariableDeclarationListAfterMetadata_const_type', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseVariableDeclarationList2_var);
+        runJUnitTest(__test, __test.test_parseVariableDeclarationListAfterMetadata_const_type);
       });
-      _ut.test('test_parseVariableDeclarationList_const_noType', () {
+      _ut.test('test_parseVariableDeclarationListAfterMetadata_final_noType', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseVariableDeclarationList_const_noType);
+        runJUnitTest(__test, __test.test_parseVariableDeclarationListAfterMetadata_final_noType);
       });
-      _ut.test('test_parseVariableDeclarationList_const_type', () {
+      _ut.test('test_parseVariableDeclarationListAfterMetadata_final_type', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseVariableDeclarationList_const_type);
+        runJUnitTest(__test, __test.test_parseVariableDeclarationListAfterMetadata_final_type);
       });
-      _ut.test('test_parseVariableDeclarationList_final_noType', () {
+      _ut.test('test_parseVariableDeclarationListAfterMetadata_type_multiple', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseVariableDeclarationList_final_noType);
+        runJUnitTest(__test, __test.test_parseVariableDeclarationListAfterMetadata_type_multiple);
       });
-      _ut.test('test_parseVariableDeclarationList_final_type', () {
+      _ut.test('test_parseVariableDeclarationListAfterMetadata_type_single', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseVariableDeclarationList_final_type);
+        runJUnitTest(__test, __test.test_parseVariableDeclarationListAfterMetadata_type_single);
       });
-      _ut.test('test_parseVariableDeclarationList_type_multiple', () {
+      _ut.test('test_parseVariableDeclarationListAfterMetadata_var_multiple', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseVariableDeclarationList_type_multiple);
+        runJUnitTest(__test, __test.test_parseVariableDeclarationListAfterMetadata_var_multiple);
       });
-      _ut.test('test_parseVariableDeclarationList_type_single', () {
+      _ut.test('test_parseVariableDeclarationListAfterMetadata_var_single', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseVariableDeclarationList_type_single);
+        runJUnitTest(__test, __test.test_parseVariableDeclarationListAfterMetadata_var_single);
       });
-      _ut.test('test_parseVariableDeclarationList_var_multiple', () {
+      _ut.test('test_parseVariableDeclarationListAfterType_type', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseVariableDeclarationList_var_multiple);
+        runJUnitTest(__test, __test.test_parseVariableDeclarationListAfterType_type);
       });
-      _ut.test('test_parseVariableDeclarationList_var_single', () {
+      _ut.test('test_parseVariableDeclarationListAfterType_var', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseVariableDeclarationList_var_single);
+        runJUnitTest(__test, __test.test_parseVariableDeclarationListAfterType_var);
       });
-      _ut.test('test_parseVariableDeclarationStatement_multiple', () {
+      _ut.test('test_parseVariableDeclarationStatementAfterMetadata_multiple', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseVariableDeclarationStatement_multiple);
+        runJUnitTest(__test, __test.test_parseVariableDeclarationStatementAfterMetadata_multiple);
       });
-      _ut.test('test_parseVariableDeclarationStatement_single', () {
+      _ut.test('test_parseVariableDeclarationStatementAfterMetadata_single', () {
         final __test = new SimpleParserTest();
-        runJUnitTest(__test, __test.test_parseVariableDeclarationStatement_single);
+        runJUnitTest(__test, __test.test_parseVariableDeclarationStatementAfterMetadata_single);
       });
       _ut.test('test_parseVariableDeclaration_equals', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseVariableDeclaration_equals);
       });
       _ut.test('test_parseVariableDeclaration_noEquals', () {
         final __test = new SimpleParserTest();
         runJUnitTest(__test, __test.test_parseVariableDeclaration_noEquals);
       });
       _ut.test('test_parseWhileStatement', () {
@@ skipping 112 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].
  */
 class ComplexParserTest extends ParserTestCase {
   void test_additiveExpression_normal() {
     BinaryExpression expression = ParserTestCase.parseExpression("x + y - z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_additiveExpression_noSpaces() {
     BinaryExpression expression = ParserTestCase.parseExpression("i+1", []);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
-    EngineTestCase.assertInstanceOf(IntegerLiteral, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is IntegerLiteral, IntegerLiteral, expression.rightOperand);
   }
 
   void test_additiveExpression_precedence_multiplicative_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("x * y + z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_additiveExpression_precedence_multiplicative_left_withSuper() {
     BinaryExpression expression = ParserTestCase.parseExpression("super * y - z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_additiveExpression_precedence_multiplicative_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("x + y * z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.rightOperand);
   }
 
   void test_additiveExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super + y - z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_assignableExpression_arguments_normal_chain() {
     PropertyAccess propertyAccess1 = ParserTestCase.parseExpression("a(b)(c).d(e).f", []);
     JUnitTestCase.assertEquals("f", propertyAccess1.propertyName.name);
     //
     // a(b)(c).d(e)
     //
-    MethodInvocation invocation2 = EngineTestCase.assertInstanceOf(MethodInvocation, propertyAccess1.target);
+    MethodInvocation invocation2 = EngineTestCase.assertInstanceOf((obj) => obj is MethodInvocation, MethodInvocation, propertyAccess1.target);
     JUnitTestCase.assertEquals("d", invocation2.methodName.name);
     ArgumentList argumentList2 = invocation2.argumentList;
     JUnitTestCase.assertNotNull(argumentList2);
     EngineTestCase.assertSize(1, argumentList2.arguments);
     //
     // a(b)(c)
     //
-    FunctionExpressionInvocation invocation3 = EngineTestCase.assertInstanceOf(FunctionExpressionInvocation, invocation2.target);
+    FunctionExpressionInvocation invocation3 = EngineTestCase.assertInstanceOf((obj) => obj is FunctionExpressionInvocation, FunctionExpressionInvocation, invocation2.target);
     ArgumentList argumentList3 = invocation3.argumentList;
     JUnitTestCase.assertNotNull(argumentList3);
     EngineTestCase.assertSize(1, argumentList3.arguments);
     //
     // a(b)
     //
-    MethodInvocation invocation4 = EngineTestCase.assertInstanceOf(MethodInvocation, invocation3.function);
+    MethodInvocation invocation4 = EngineTestCase.assertInstanceOf((obj) => obj is MethodInvocation, MethodInvocation, invocation3.function);
     JUnitTestCase.assertEquals("a", invocation4.methodName.name);
     ArgumentList argumentList4 = invocation4.argumentList;
     JUnitTestCase.assertNotNull(argumentList4);
     EngineTestCase.assertSize(1, argumentList4.arguments);
   }
 
   void test_assignmentExpression_compound() {
     AssignmentExpression expression = ParserTestCase.parseExpression("x = y = 0", []);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftHandSide);
-    EngineTestCase.assertInstanceOf(AssignmentExpression, expression.rightHandSide);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftHandSide);
+    EngineTestCase.assertInstanceOf((obj) => obj is AssignmentExpression, AssignmentExpression, expression.rightHandSide);
   }
 
   void test_assignmentExpression_indexExpression() {
     AssignmentExpression expression = ParserTestCase.parseExpression("x[1] = 0", []);
-    EngineTestCase.assertInstanceOf(IndexExpression, expression.leftHandSide);
-    EngineTestCase.assertInstanceOf(IntegerLiteral, expression.rightHandSide);
+    EngineTestCase.assertInstanceOf((obj) => obj is IndexExpression, IndexExpression, expression.leftHandSide);
+    EngineTestCase.assertInstanceOf((obj) => obj is IntegerLiteral, IntegerLiteral, expression.rightHandSide);
   }
 
   void test_assignmentExpression_prefixedIdentifier() {
     AssignmentExpression expression = ParserTestCase.parseExpression("x.y = 0", []);
-    EngineTestCase.assertInstanceOf(PrefixedIdentifier, expression.leftHandSide);
-    EngineTestCase.assertInstanceOf(IntegerLiteral, expression.rightHandSide);
+    EngineTestCase.assertInstanceOf((obj) => obj is PrefixedIdentifier, PrefixedIdentifier, expression.leftHandSide);
+    EngineTestCase.assertInstanceOf((obj) => obj is IntegerLiteral, IntegerLiteral, expression.rightHandSide);
   }
 
   void test_assignmentExpression_propertyAccess() {
     AssignmentExpression expression = ParserTestCase.parseExpression("super.y = 0", []);
-    EngineTestCase.assertInstanceOf(PropertyAccess, expression.leftHandSide);
-    EngineTestCase.assertInstanceOf(IntegerLiteral, expression.rightHandSide);
+    EngineTestCase.assertInstanceOf((obj) => obj is PropertyAccess, PropertyAccess, expression.leftHandSide);
+    EngineTestCase.assertInstanceOf((obj) => obj is IntegerLiteral, IntegerLiteral, expression.rightHandSide);
   }
 
   void test_bitwiseAndExpression_normal() {
     BinaryExpression expression = ParserTestCase.parseExpression("x & y & z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_bitwiseAndExpression_precedence_equality_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("x == y && z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_bitwiseAndExpression_precedence_equality_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("x && y == z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.rightOperand);
   }
 
   void test_bitwiseAndExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super & y & z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_bitwiseOrExpression_normal() {
     BinaryExpression expression = ParserTestCase.parseExpression("x | y | z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_bitwiseOrExpression_precedence_xor_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("x ^ y | z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_bitwiseOrExpression_precedence_xor_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("x | y ^ z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.rightOperand);
   }
 
   void test_bitwiseOrExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super | y | z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_bitwiseXorExpression_normal() {
     BinaryExpression expression = ParserTestCase.parseExpression("x ^ y ^ z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_bitwiseXorExpression_precedence_and_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("x & y ^ z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_bitwiseXorExpression_precedence_and_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("x ^ y & z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.rightOperand);
   }
 
   void test_bitwiseXorExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super ^ y ^ z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_cascade_withAssignment() {
     CascadeExpression cascade = ParserTestCase.parseExpression("new Map()..[3] = 4 ..[0] = 11;", []);
     Expression target = cascade.target;
     for (Expression section in cascade.cascadeSections) {
-      EngineTestCase.assertInstanceOf(AssignmentExpression, section);
+      EngineTestCase.assertInstanceOf((obj) => obj is AssignmentExpression, AssignmentExpression, section);
       Expression lhs = (section as AssignmentExpression).leftHandSide;
-      EngineTestCase.assertInstanceOf(IndexExpression, lhs);
+      EngineTestCase.assertInstanceOf((obj) => obj is IndexExpression, IndexExpression, lhs);
       IndexExpression index = lhs as IndexExpression;
       JUnitTestCase.assertTrue(index.isCascaded);
       JUnitTestCase.assertSame(target, index.realTarget);
     }
   }
 
   void test_conditionalExpression_precedence_logicalOrExpression() {
     ConditionalExpression expression = ParserTestCase.parseExpression("a | b ? y : z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.condition);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.condition);
   }
 
   void test_constructor_initializer_withParenthesizedExpression() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(EngineTestCase.createSource([
         "class C {",
         "  C() :",
         "    this.a = (b == null ? c : d) {",
         "  }",
         "}"]), []);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     EngineTestCase.assertSize(1, declarations);
   }
 
   void test_equalityExpression_normal() {
     BinaryExpression expression = ParserTestCase.parseExpression("x == y != z", [ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_equalityExpression_precedence_relational_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("x is y == z", []);
-    EngineTestCase.assertInstanceOf(IsExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is IsExpression, IsExpression, expression.leftOperand);
   }
 
   void test_equalityExpression_precedence_relational_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("x == y is z", []);
-    EngineTestCase.assertInstanceOf(IsExpression, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is IsExpression, IsExpression, expression.rightOperand);
   }
 
   void test_equalityExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super == y != z", [ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_logicalAndExpression() {
     BinaryExpression expression = ParserTestCase.parseExpression("x && y && z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_logicalAndExpression_precedence_bitwiseOr_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("x | y < z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_logicalAndExpression_precedence_bitwiseOr_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("x < y | z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.rightOperand);
   }
 
   void test_logicalOrExpression() {
     BinaryExpression expression = ParserTestCase.parseExpression("x || y || z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_logicalOrExpression_precedence_logicalAnd_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("x && y || z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_logicalOrExpression_precedence_logicalAnd_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("x || y && z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.rightOperand);
   }
 
   void test_multipleLabels_statement() {
     LabeledStatement statement = ParserTestCase.parseStatement("a: b: c: return x;", []);
     EngineTestCase.assertSize(3, statement.labels);
-    EngineTestCase.assertInstanceOf(ReturnStatement, statement.statement);
+    EngineTestCase.assertInstanceOf((obj) => obj is ReturnStatement, ReturnStatement, statement.statement);
   }
 
   void test_multiplicativeExpression_normal() {
     BinaryExpression expression = ParserTestCase.parseExpression("x * y / z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_multiplicativeExpression_precedence_unary_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("-x * y", []);
-    EngineTestCase.assertInstanceOf(PrefixExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is PrefixExpression, PrefixExpression, expression.leftOperand);
   }
 
   void test_multiplicativeExpression_precedence_unary_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("x * -y", []);
-    EngineTestCase.assertInstanceOf(PrefixExpression, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is PrefixExpression, PrefixExpression, expression.rightOperand);
   }
 
   void test_multiplicativeExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super * y / z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_relationalExpression_precedence_shift_right() {
     IsExpression expression = ParserTestCase.parseExpression("x << y is z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.expression);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.expression);
   }
 
   void test_shiftExpression_normal() {
     BinaryExpression expression = ParserTestCase.parseExpression("x >> 4 << 3", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_shiftExpression_precedence_additive_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("x + y << z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_shiftExpression_precedence_additive_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("x << y + z", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.rightOperand);
   }
 
   void test_shiftExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super >> 4 << 3", []);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_topLevelVariable_withMetadata() {
     ParserTestCase.parseCompilationUnit("String @A string;", []);
   }
 
   static dartSuite() {
     _ut.group('ComplexParserTest', () {
       _ut.test('test_additiveExpression_noSpaces', () {
         final __test = new ComplexParserTest();
@@ skipping 1270 matching lines @@
         "  Map<Symbol, dynamic> result = new Map<Symbol, dynamic>();",
         "  map.forEach((name, value) {",
         "    result[new Symbol(name)] = value;",
         "  });",
         "  return result;",
         "}"]), []);
   }
 
   void test_additiveExpression_missing_LHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("+ y", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic);
   }
 
   void test_additiveExpression_missing_LHS_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("+", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_additiveExpression_missing_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("x +", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_additiveExpression_missing_RHS_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super +", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_additiveExpression_precedence_multiplicative_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("* +", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_additiveExpression_precedence_multiplicative_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("+ *", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.rightOperand);
   }
 
   void test_additiveExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super + +", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_assignmentExpression_missing_compound1() {
     AssignmentExpression expression = ParserTestCase.parseExpression("= y = 0", [ParserErrorCode.MISSING_IDENTIFIER]);
     Expression syntheticExpression = expression.leftHandSide;
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, syntheticExpression);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, syntheticExpression);
     JUnitTestCase.assertTrue(syntheticExpression.isSynthetic);
   }
 
   void test_assignmentExpression_missing_compound2() {
     AssignmentExpression expression = ParserTestCase.parseExpression("x = = 0", [ParserErrorCode.MISSING_IDENTIFIER]);
     Expression syntheticExpression = (expression.rightHandSide as AssignmentExpression).leftHandSide;
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, syntheticExpression);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, syntheticExpression);
     JUnitTestCase.assertTrue(syntheticExpression.isSynthetic);
   }
 
   void test_assignmentExpression_missing_compound3() {
     AssignmentExpression expression = ParserTestCase.parseExpression("x = y =", [ParserErrorCode.MISSING_IDENTIFIER]);
     Expression syntheticExpression = (expression.rightHandSide as AssignmentExpression).rightHandSide;
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, syntheticExpression);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, syntheticExpression);
     JUnitTestCase.assertTrue(syntheticExpression.isSynthetic);
   }
 
   void test_assignmentExpression_missing_LHS() {
     AssignmentExpression expression = ParserTestCase.parseExpression("= 0", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftHandSide);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftHandSide);
     JUnitTestCase.assertTrue(expression.leftHandSide.isSynthetic);
   }
 
   void test_assignmentExpression_missing_RHS() {
     AssignmentExpression expression = ParserTestCase.parseExpression("x =", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftHandSide);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftHandSide);
     JUnitTestCase.assertTrue(expression.rightHandSide.isSynthetic);
   }
 
   void test_bitwiseAndExpression_missing_LHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("& y", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic);
   }
 
   void test_bitwiseAndExpression_missing_LHS_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("&", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_bitwiseAndExpression_missing_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("x &", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_bitwiseAndExpression_missing_RHS_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super &", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_bitwiseAndExpression_precedence_equality_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("== &&", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_bitwiseAndExpression_precedence_equality_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("&& ==", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.rightOperand);
   }
 
   void test_bitwiseAndExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super &  &", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_bitwiseOrExpression_missing_LHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("| y", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic);
   }
 
   void test_bitwiseOrExpression_missing_LHS_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("|", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_bitwiseOrExpression_missing_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("x |", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_bitwiseOrExpression_missing_RHS_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super |", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_bitwiseOrExpression_precedence_xor_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("^ |", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_bitwiseOrExpression_precedence_xor_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("| ^", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.rightOperand);
   }
 
   void test_bitwiseOrExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super |  |", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_bitwiseXorExpression_missing_LHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("^ y", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic);
   }
 
   void test_bitwiseXorExpression_missing_LHS_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("^", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_bitwiseXorExpression_missing_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("x ^", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_bitwiseXorExpression_missing_RHS_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super ^", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_bitwiseXorExpression_precedence_and_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("& ^", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_bitwiseXorExpression_precedence_and_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("^ &", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.rightOperand);
   }
 
   void test_bitwiseXorExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super ^  ^", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_classTypeAlias_withBody() {
     ParserTestCase.parseCompilationUnit(EngineTestCase.createSource(["class A {}", "class B = Object with A {}"]), [ParserErrorCode.EXPECTED_TOKEN]);
   }
 
   void test_conditionalExpression_missingElse() {
     ConditionalExpression expression = ParserTestCase.parse4("parseConditionalExpression", "x ? y :", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.elseExpression);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.elseExpression);
     JUnitTestCase.assertTrue(expression.elseExpression.isSynthetic);
   }
 
   void test_conditionalExpression_missingThen() {
     ConditionalExpression expression = ParserTestCase.parse4("parseConditionalExpression", "x ? : z", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.thenExpression);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.thenExpression);
     JUnitTestCase.assertTrue(expression.thenExpression.isSynthetic);
   }
 
   void test_equalityExpression_missing_LHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("== y", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic);
   }
 
   void test_equalityExpression_missing_LHS_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("==", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_equalityExpression_missing_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("x ==", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_equalityExpression_missing_RHS_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super ==", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_equalityExpression_precedence_relational_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("is ==", [
         ParserErrorCode.EXPECTED_TYPE_NAME,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(IsExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is IsExpression, IsExpression, expression.leftOperand);
   }
 
   void test_equalityExpression_precedence_relational_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("== is", [
         ParserErrorCode.EXPECTED_TYPE_NAME,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(IsExpression, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is IsExpression, IsExpression, expression.rightOperand);
   }
 
   void test_equalityExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super ==  ==", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_expressionList_multiple_end() {
     List<Expression> result = ParserTestCase.parse4("parseExpressionList", ", 2, 3, 4", [ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertSize(4, result);
     Expression syntheticExpression = result[0];
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, syntheticExpression);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, syntheticExpression);
     JUnitTestCase.assertTrue(syntheticExpression.isSynthetic);
   }
 
   void test_expressionList_multiple_middle() {
     List<Expression> result = ParserTestCase.parse4("parseExpressionList", "1, 2, , 4", [ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertSize(4, result);
     Expression syntheticExpression = result[2];
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, syntheticExpression);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, syntheticExpression);
     JUnitTestCase.assertTrue(syntheticExpression.isSynthetic);
   }
 
   void test_expressionList_multiple_start() {
     List<Expression> result = ParserTestCase.parse4("parseExpressionList", "1, 2, 3,", [ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertSize(4, result);
     Expression syntheticExpression = result[3];
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, syntheticExpression);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, syntheticExpression);
     JUnitTestCase.assertTrue(syntheticExpression.isSynthetic);
   }
 
   void test_incomplete_topLevelVariable() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("String", [ParserErrorCode.EXPECTED_EXECUTABLE]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     EngineTestCase.assertSize(1, declarations);
     CompilationUnitMember member = declarations[0];
-    EngineTestCase.assertInstanceOf(TopLevelVariableDeclaration, member);
+    EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableDeclaration, TopLevelVariableDeclaration, member);
     NodeList<VariableDeclaration> variables = (member as TopLevelVariableDeclaration).variables.variables;
     EngineTestCase.assertSize(1, variables);
     SimpleIdentifier name = variables[0].name;
     JUnitTestCase.assertTrue(name.isSynthetic);
   }
 
   void test_isExpression_noType() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("class Bar<T extends Foo> {m(x){if (x is ) return;if (x is !)}}", [
         ParserErrorCode.EXPECTED_TYPE_NAME,
         ParserErrorCode.EXPECTED_TYPE_NAME,
         ParserErrorCode.MISSING_STATEMENT]);
     ClassDeclaration declaration = unit.declarations[0] as ClassDeclaration;
     MethodDeclaration method = declaration.members[0] as MethodDeclaration;
     BlockFunctionBody body = method.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[1] as IfStatement;
     IsExpression expression = ifStatement.condition as IsExpression;
     JUnitTestCase.assertNotNull(expression.expression);
     JUnitTestCase.assertNotNull(expression.isOperator);
     JUnitTestCase.assertNotNull(expression.notOperator);
     TypeName type = expression.type;
     JUnitTestCase.assertNotNull(type);
     JUnitTestCase.assertTrue(type.name.isSynthetic);
-    EngineTestCase.assertInstanceOf(EmptyStatement, ifStatement.thenStatement);
+    EngineTestCase.assertInstanceOf((obj) => obj is EmptyStatement, EmptyStatement, ifStatement.thenStatement);
   }
 
   void test_logicalAndExpression_missing_LHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("&& y", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic);
   }
 
   void test_logicalAndExpression_missing_LHS_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("&&", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_logicalAndExpression_missing_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("x &&", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_logicalAndExpression_precedence_bitwiseOr_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("| &&", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_logicalAndExpression_precedence_bitwiseOr_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("&& |", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.rightOperand);
   }
 
   void test_logicalOrExpression_missing_LHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("|| y", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic);
   }
 
   void test_logicalOrExpression_missing_LHS_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("||", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_logicalOrExpression_missing_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("x ||", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_logicalOrExpression_precedence_logicalAnd_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("&& ||", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_logicalOrExpression_precedence_logicalAnd_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("|| &&", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.rightOperand);
   }
 
   void test_missingIdentifier_afterAnnotation() {
     MethodDeclaration method = ParserTestCase.parse3("parseClassMember", <Object> ["C"], "@override }", [ParserErrorCode.EXPECTED_CLASS_MEMBER]);
     JUnitTestCase.assertNull(method.documentationComment);
     NodeList<Annotation> metadata = method.metadata;
     EngineTestCase.assertSize(1, metadata);
     JUnitTestCase.assertEquals("override", metadata[0].name.name);
   }
 
   void test_multiplicativeExpression_missing_LHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("* y", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic);
   }
 
   void test_multiplicativeExpression_missing_LHS_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("*", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_multiplicativeExpression_missing_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("x *", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_multiplicativeExpression_missing_RHS_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super *", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_multiplicativeExpression_precedence_unary_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("-x *", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(PrefixExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is PrefixExpression, PrefixExpression, expression.leftOperand);
   }
 
   void test_multiplicativeExpression_precedence_unary_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("* -y", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(PrefixExpression, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is PrefixExpression, PrefixExpression, expression.rightOperand);
   }
 
   void test_multiplicativeExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super ==  ==", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_prefixExpression_missing_operand_minus() {
     PrefixExpression expression = ParserTestCase.parseExpression("-", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.operand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.operand);
     JUnitTestCase.assertTrue(expression.operand.isSynthetic);
     JUnitTestCase.assertEquals(TokenType.MINUS, expression.operator.type);
   }
 
   void test_relationalExpression_missing_LHS() {
     IsExpression expression = ParserTestCase.parseExpression("is y", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.expression);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.expression);
     JUnitTestCase.assertTrue(expression.expression.isSynthetic);
   }
 
   void test_relationalExpression_missing_LHS_RHS() {
     IsExpression expression = ParserTestCase.parseExpression("is", [
         ParserErrorCode.EXPECTED_TYPE_NAME,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.expression);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.expression);
     JUnitTestCase.assertTrue(expression.expression.isSynthetic);
-    EngineTestCase.assertInstanceOf(TypeName, expression.type);
+    EngineTestCase.assertInstanceOf((obj) => obj is TypeName, TypeName, expression.type);
     JUnitTestCase.assertTrue(expression.type.isSynthetic);
   }
 
   void test_relationalExpression_missing_RHS() {
     IsExpression expression = ParserTestCase.parseExpression("x is", [ParserErrorCode.EXPECTED_TYPE_NAME]);
-    EngineTestCase.assertInstanceOf(TypeName, expression.type);
+    EngineTestCase.assertInstanceOf((obj) => obj is TypeName, TypeName, expression.type);
     JUnitTestCase.assertTrue(expression.type.isSynthetic);
   }
 
   void test_relationalExpression_precedence_shift_right() {
     IsExpression expression = ParserTestCase.parseExpression("<< is", [
         ParserErrorCode.EXPECTED_TYPE_NAME,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.expression);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.expression);
   }
 
   void test_shiftExpression_missing_LHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("<< y", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic);
   }
 
   void test_shiftExpression_missing_LHS_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("<<", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_shiftExpression_missing_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("x <<", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_shiftExpression_missing_RHS_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super <<", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.rightOperand);
     JUnitTestCase.assertTrue(expression.rightOperand.isSynthetic);
   }
 
   void test_shiftExpression_precedence_unary_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("+ <<", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_shiftExpression_precedence_unary_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("<< +", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.rightOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.rightOperand);
   }
 
   void test_shiftExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super << <<", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
+    EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_typedef_eof() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("typedef n", [
         ParserErrorCode.EXPECTED_TOKEN,
         ParserErrorCode.MISSING_TYPEDEF_PARAMETERS]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     EngineTestCase.assertSize(1, declarations);
     CompilationUnitMember member = declarations[0];
-    EngineTestCase.assertInstanceOf(FunctionTypeAlias, member);
+    EngineTestCase.assertInstanceOf((obj) => obj is FunctionTypeAlias, FunctionTypeAlias, member);
   }
 
   static dartSuite() {
     _ut.group('RecoveryParserTest', () {
       _ut.test('test_additiveExpression_missing_LHS', () {
         final __test = new RecoveryParserTest();
         runJUnitTest(__test, __test.test_additiveExpression_missing_LHS);
       });
       _ut.test('test_additiveExpression_missing_LHS_RHS', () {
         final __test = new RecoveryParserTest();
@@ skipping 753 matching lines @@
   }
 
   void fail_missingFunctionParameters_local_nonVoid_expression() {
     // The parser does not recognize this as a function declaration, so it tries to parse it as an
     // expression statement. It isn't clear what the best error message is in this case.
     ParserTestCase.parseStatement("int f => x;", [ParserErrorCode.MISSING_FUNCTION_PARAMETERS]);
   }
 
   void fail_namedFunctionExpression() {
     Expression expression = ParserTestCase.parse4("parsePrimaryExpression", "f() {}", [ParserErrorCode.NAMED_FUNCTION_EXPRESSION]);
-    EngineTestCase.assertInstanceOf(FunctionExpression, expression);
+    EngineTestCase.assertInstanceOf((obj) => obj is FunctionExpression, FunctionExpression, expression);
   }
 
   void fail_unexpectedToken_invalidPostfixExpression() {
     // Note: this might not be the right error to produce, but some error should be produced
     ParserTestCase.parseExpression("f()++", [ParserErrorCode.UNEXPECTED_TOKEN]);
   }
 
   void fail_varAndType_local() {
     // This is currently reporting EXPECTED_TOKEN for a missing semicolon, but this would be a
     // better error message.
@@ skipping 915 matching lines @@
   void test_unexpectedToken_semicolonBetweenClassMembers() {
     ParserTestCase.parse3("parseClassDeclaration", <Object> [emptyCommentAndMetadata(), null], "class C { int x; ; int y;}", [ParserErrorCode.UNEXPECTED_TOKEN]);
   }
 
   void test_unexpectedToken_semicolonBetweenCompilationUnitMembers() {
     ParserTestCase.parseCompilationUnit("int x; ; int y;", [ParserErrorCode.UNEXPECTED_TOKEN]);
   }
 
   void test_useOfUnaryPlusOperator() {
     SimpleIdentifier expression = ParserTestCase.parse4("parseUnaryExpression", "+x", [ParserErrorCode.MISSING_IDENTIFIER]);
-    EngineTestCase.assertInstanceOf(SimpleIdentifier, expression);
+    EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression);
     JUnitTestCase.assertTrue(expression.isSynthetic);
   }
 
   void test_varAndType_field() {
     ParserTestCase.parseCompilationUnit("class C { var int x; }", [ParserErrorCode.VAR_AND_TYPE]);
   }
 
   void test_varAndType_topLevelVariable() {
     ParserTestCase.parseCompilationUnit("var int x;", [ParserErrorCode.VAR_AND_TYPE]);
   }
@@ skipping 1091 matching lines @@
   '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()),
   'parseWithClause_0': new MethodTrampoline(0, (Parser target) => target.parseWithClause()),
   'advance_0': new MethodTrampoline(0, (Parser target) => target.advance()),
   'appendScalarValue_5': new MethodTrampoline(5, (Parser target, arg0, arg1, arg2, arg3, arg4) => target.appendScalarValue(arg0, arg1, arg2, arg3, arg4)),
   'computeStringValue_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target.computeStringValue(arg0, arg1, arg2)),
   'convertToFunctionDeclaration_1': new MethodTrampoline(1, (Parser target, arg0) => target.convertToFunctionDeclaration(arg0)),
   'couldBeStartOfCompilationUnitMember_0': new MethodTrampoline(0, (Parser target) => target.couldBeStartOfCompilationUnitMember()),
   'createSyntheticIdentifier_0': new MethodTrampoline(0, (Parser target) => target.createSyntheticIdentifier()),
+  'createSyntheticKeyword_1': new MethodTrampoline(1, (Parser target, arg0) => target.createSyntheticKeyword(arg0)),
   '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)),
+  'expectKeyword_1': new MethodTrampoline(1, (Parser target, arg0) => target.expectKeyword(arg0)),
   'expectSemicolon_0': new MethodTrampoline(0, (Parser target) => target.expectSemicolon()),
   'findRange_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.findRange(arg0, arg1)),
   'getCodeBlockRanges_1': new MethodTrampoline(1, (Parser target, arg0) => target.getCodeBlockRanges(arg0)),
   'getEndToken_1': new MethodTrampoline(1, (Parser target, arg0) => target.getEndToken(arg0)),
   'hasReturnTypeInTypeAlias_0': new MethodTrampoline(0, (Parser target) => target.hasReturnTypeInTypeAlias()),
   'injectToken_1': new MethodTrampoline(1, (Parser target, arg0) => target.injectToken(arg0)),
   '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()),
   'isLinkText_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.isLinkText(arg0, arg1)),
   'isOperator_1': new MethodTrampoline(1, (Parser target, arg0) => target.isOperator(arg0)),
   'isSwitchMember_0': new MethodTrampoline(0, (Parser target) => target.isSwitchMember()),
   'isTypedIdentifier_1': new MethodTrampoline(1, (Parser target, arg0) => target.isTypedIdentifier(arg0)),
   'lexicallyFirst_1': new MethodTrampoline(1, (Parser target, arg0) => target.lexicallyFirst(arg0)),
   'lockErrorListener_0': new MethodTrampoline(0, (Parser target) => target.lockErrorListener()),
   '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)),
+  'matchesKeyword_1': new MethodTrampoline(1, (Parser target, arg0) => target.matchesKeyword(arg0)),
+  'matchesString_1': new MethodTrampoline(1, (Parser target, arg0) => target.matchesString(arg0)),
   'optional_1': new MethodTrampoline(1, (Parser target, arg0) => target.optional(arg0)),
   'parseAdditiveExpression_0': new MethodTrampoline(0, (Parser target) => target.parseAdditiveExpression()),
   'parseArgumentDefinitionTest_0': new MethodTrampoline(0, (Parser target) => target.parseArgumentDefinitionTest()),
   'parseAssertStatement_0': new MethodTrampoline(0, (Parser target) => target.parseAssertStatement()),
   'parseAssignableExpression_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseAssignableExpression(arg0)),
   'parseAssignableSelector_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.parseAssignableSelector(arg0, arg1)),
   'parseBitwiseAndExpression_0': new MethodTrampoline(0, (Parser target) => target.parseBitwiseAndExpression()),
   'parseBitwiseXorExpression_0': new MethodTrampoline(0, (Parser target) => target.parseBitwiseXorExpression()),
   'parseBreakStatement_0': new MethodTrampoline(0, (Parser target) => target.parseBreakStatement()),
   'parseCascadeSection_0': new MethodTrampoline(0, (Parser target) => target.parseCascadeSection()),
@@ skipping 15 matching lines @@
   'parseEmptyStatement_0': new MethodTrampoline(0, (Parser target) => target.parseEmptyStatement()),
   'parseEqualityExpression_0': new MethodTrampoline(0, (Parser target) => target.parseEqualityExpression()),
   'parseExportDirective_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseExportDirective(arg0)),
   'parseExpressionList_0': new MethodTrampoline(0, (Parser target) => target.parseExpressionList()),
   'parseFinalConstVarOrType_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseFinalConstVarOrType(arg0)),
   'parseFormalParameter_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseFormalParameter(arg0)),
   'parseForStatement_0': new MethodTrampoline(0, (Parser target) => target.parseForStatement()),
   'parseFunctionBody_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target.parseFunctionBody(arg0, arg1, arg2)),
   'parseFunctionDeclaration_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target.parseFunctionDeclaration(arg0, arg1, arg2)),
   'parseFunctionDeclarationStatement_0': new MethodTrampoline(0, (Parser target) => target.parseFunctionDeclarationStatement()),
-  'parseFunctionDeclarationStatement_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.parseFunctionDeclarationStatement2(arg0, arg1)),
+  'parseFunctionDeclarationStatementAfterReturnType_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.parseFunctionDeclarationStatementAfterReturnType(arg0, arg1)),
   'parseFunctionTypeAlias_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.parseFunctionTypeAlias(arg0, arg1)),
   'parseGetter_4': new MethodTrampoline(4, (Parser target, arg0, arg1, arg2, arg3) => target.parseGetter(arg0, arg1, arg2, arg3)),
   'parseIdentifierList_0': new MethodTrampoline(0, (Parser target) => target.parseIdentifierList()),
   'parseIfStatement_0': new MethodTrampoline(0, (Parser target) => target.parseIfStatement()),
   'parseImportDirective_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseImportDirective(arg0)),
   'parseInitializedIdentifierList_4': new MethodTrampoline(4, (Parser target, arg0, arg1, arg2, arg3) => target.parseInitializedIdentifierList(arg0, arg1, arg2, arg3)),
   'parseInstanceCreationExpression_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseInstanceCreationExpression(arg0)),
   'parseLibraryDirective_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseLibraryDirective(arg0)),
   'parseLibraryName_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.parseLibraryName(arg0, arg1)),
   'parseListLiteral_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.parseListLiteral(arg0, arg1)),
   'parseListOrMapLiteral_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseListOrMapLiteral(arg0)),
   'parseLogicalAndExpression_0': new MethodTrampoline(0, (Parser target) => target.parseLogicalAndExpression()),
   'parseMapLiteral_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.parseMapLiteral(arg0, arg1)),
-  'parseMethodDeclaration_4': new MethodTrampoline(4, (Parser target, arg0, arg1, arg2, arg3) => target.parseMethodDeclaration(arg0, arg1, arg2, arg3)),
-  'parseMethodDeclaration_6': new MethodTrampoline(6, (Parser target, arg0, arg1, arg2, arg3, arg4, arg5) => target.parseMethodDeclaration2(arg0, arg1, arg2, arg3, arg4, arg5)),
+  'parseMethodDeclarationAfterParameters_6': new MethodTrampoline(6, (Parser target, arg0, arg1, arg2, arg3, arg4, arg5) => target.parseMethodDeclarationAfterParameters(arg0, arg1, arg2, arg3, arg4, arg5)),
+  'parseMethodDeclarationAfterReturnType_4': new MethodTrampoline(4, (Parser target, arg0, arg1, arg2, arg3) => target.parseMethodDeclarationAfterReturnType(arg0, arg1, arg2, arg3)),
   'parseModifiers_0': new MethodTrampoline(0, (Parser target) => target.parseModifiers()),
   'parseMultiplicativeExpression_0': new MethodTrampoline(0, (Parser target) => target.parseMultiplicativeExpression()),
   'parseNativeClause_0': new MethodTrampoline(0, (Parser target) => target.parseNativeClause()),
   'parseNewExpression_0': new MethodTrampoline(0, (Parser target) => target.parseNewExpression()),
   'parseNonLabeledStatement_0': new MethodTrampoline(0, (Parser target) => target.parseNonLabeledStatement()),
   'parseOperator_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target.parseOperator(arg0, arg1, arg2)),
   'parseOptionalReturnType_0': new MethodTrampoline(0, (Parser target) => target.parseOptionalReturnType()),
   'parsePartDirective_1': new MethodTrampoline(1, (Parser target, arg0) => target.parsePartDirective(arg0)),
   'parsePostfixExpression_0': new MethodTrampoline(0, (Parser target) => target.parsePostfixExpression()),
   'parsePrimaryExpression_0': new MethodTrampoline(0, (Parser target) => target.parsePrimaryExpression()),
   'parseRedirectingConstructorInvocation_0': new MethodTrampoline(0, (Parser target) => target.parseRedirectingConstructorInvocation()),
   'parseRelationalExpression_0': new MethodTrampoline(0, (Parser target) => target.parseRelationalExpression()),
   'parseRethrowExpression_0': new MethodTrampoline(0, (Parser target) => target.parseRethrowExpression()),
   'parseReturnStatement_0': new MethodTrampoline(0, (Parser target) => target.parseReturnStatement()),
   'parseSetter_4': new MethodTrampoline(4, (Parser target, arg0, arg1, arg2, arg3) => target.parseSetter(arg0, arg1, arg2, arg3)),
   'parseShiftExpression_0': new MethodTrampoline(0, (Parser target) => target.parseShiftExpression()),
-  'parseStatements_0': new MethodTrampoline(0, (Parser target) => target.parseStatements2()),
+  'parseStatementList_0': new MethodTrampoline(0, (Parser target) => target.parseStatementList()),
   'parseStringInterpolation_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseStringInterpolation(arg0)),
   'parseSuperConstructorInvocation_0': new MethodTrampoline(0, (Parser target) => target.parseSuperConstructorInvocation()),
   'parseSwitchStatement_0': new MethodTrampoline(0, (Parser target) => target.parseSwitchStatement()),
   'parseSymbolLiteral_0': new MethodTrampoline(0, (Parser target) => target.parseSymbolLiteral()),
   'parseThrowExpression_0': new MethodTrampoline(0, (Parser target) => target.parseThrowExpression()),
   'parseThrowExpressionWithoutCascade_0': new MethodTrampoline(0, (Parser target) => target.parseThrowExpressionWithoutCascade()),
   'parseTryStatement_0': new MethodTrampoline(0, (Parser target) => target.parseTryStatement()),
   'parseTypeAlias_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseTypeAlias(arg0)),
   '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)),
+  'parseVariableDeclarationListAfterMetadata_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseVariableDeclarationListAfterMetadata(arg0)),
+  'parseVariableDeclarationListAfterType_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target.parseVariableDeclarationListAfterType(arg0, arg1, arg2)),
+  'parseVariableDeclarationStatementAfterMetadata_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseVariableDeclarationStatementAfterMetadata(arg0)),
+  'parseVariableDeclarationStatementAfterType_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target.parseVariableDeclarationStatementAfterType(arg0, arg1, arg2)),
   'parseWhileStatement_0': new MethodTrampoline(0, (Parser target) => target.parseWhileStatement()),
   'peek_0': new MethodTrampoline(0, (Parser target) => target.peek()),
   'peek_1': new MethodTrampoline(1, (Parser target, arg0) => target.peek2(arg0)),
   'reportError_1': new MethodTrampoline(1, (Parser target, arg0) => target.reportError(arg0)),
-  'reportError_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target.reportError12(arg0, arg1, arg2)),
-  'reportError_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.reportError13(arg0, arg1)),
+  'reportErrorForCurrentToken_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.reportErrorForCurrentToken(arg0, arg1)),
+  'reportErrorForNode_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target.reportErrorForNode(arg0, arg1, arg2)),
+  'reportErrorForToken_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target.reportErrorForToken(arg0, arg1, arg2)),
   'skipBlock_0': new MethodTrampoline(0, (Parser target) => target.skipBlock()),
   '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)),
   'skipReturnType_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipReturnType(arg0)),
   'skipSimpleIdentifier_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipSimpleIdentifier(arg0)),
   'skipStringInterpolation_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipStringInterpolation(arg0)),
   'skipStringLiteral_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipStringLiteral(arg0)),
   'skipTypeArgumentList_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipTypeArgumentList(arg0)),
   'skipTypeName_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipTypeName(arg0)),
   'skipTypeParameterList_1': new MethodTrampoline(1, (Parser target, arg0) => target.skipTypeParameterList(arg0)),
+  'tokenMatches_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.tokenMatches(arg0, arg1)),
+  'tokenMatchesIdentifier_1': new MethodTrampoline(1, (Parser target, arg0) => target.tokenMatchesIdentifier(arg0)),
+  'tokenMatchesKeyword_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target.tokenMatchesKeyword(arg0, arg1)),
   'translateCharacter_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target.translateCharacter(arg0, arg1, arg2)),
   'unlockErrorListener_0': new MethodTrampoline(0, (Parser target) => target.unlockErrorListener()),
   'validateFormalParameterList_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateFormalParameterList(arg0)),
   'validateModifiersForClass_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForClass(arg0)),
   'validateModifiersForConstructor_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForConstructor(arg0)),
   'validateModifiersForField_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForField(arg0)),
   'validateModifiersForFunctionDeclarationStatement_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForFunctionDeclarationStatement(arg0)),
   'validateModifiersForGetterOrSetterOrMethod_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForGetterOrSetterOrMethod(arg0)),
   'validateModifiersForOperator_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForOperator(arg0)),
   'validateModifiersForTopLevelDeclaration_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForTopLevelDeclaration(arg0)),
   '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);
 }