Generate unique names less aggressively.

pkg/analyzer_experimental/test/generated/parser_test.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.parser_test;
 
 import 'dart:collection';
 import 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_engine.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/source.dart';
 import 'package:analyzer_experimental/src/generated/error.dart';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
 import 'package:analyzer_experimental/src/generated/ast.dart';
 import 'package:analyzer_experimental/src/generated/parser.dart';
 import 'package:analyzer_experimental/src/generated/utilities_dart.dart';
 import 'package:unittest/unittest.dart' as _ut;
 import 'test_support.dart';
 import 'scanner_test.dart' show TokenFactory;
 
 /**
  * The class {@code SimpleParserTest} defines parser tests that test individual parsing method. The
  * code fragments should be as minimal as possible in order to test the method, but should not test
  * the interactions between the method under test and other methods.
  * <p>
  * More complex tests should be defined in the class {@link ComplexParserTest}.
  */
 class SimpleParserTest extends ParserTestCase {
   void fail_parseCommentReference_this() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["this", 5], "");
-    SimpleIdentifier identifier21 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
-    JUnitTestCase.assertNotNull(identifier21.token);
-    JUnitTestCase.assertEquals("a", identifier21.name);
-    JUnitTestCase.assertEquals(5, identifier21.offset);
+    SimpleIdentifier identifier2 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
+    JUnitTestCase.assertNotNull(identifier2.token);
+    JUnitTestCase.assertEquals("a", identifier2.name);
+    JUnitTestCase.assertEquals(5, identifier2.offset);
   }
   void test_computeStringValue_emptyInterpolationPrefix() {
     JUnitTestCase.assertEquals("", computeStringValue("'''"));
   }
   void test_computeStringValue_escape_b() {
     JUnitTestCase.assertEquals("\b", computeStringValue("'\\b'"));
   }
   void test_computeStringValue_escape_f() {
     JUnitTestCase.assertEquals("\f", computeStringValue("'\\f'"));
   }
@@ skipping 212 matching lines @@
   void test_parseAnnotation_n3_a() {
     Annotation annotation = ParserTestCase.parse5("parseAnnotation", "@A.B.C(x,y)", []);
     JUnitTestCase.assertNotNull(annotation.atSign);
     JUnitTestCase.assertNotNull(annotation.name);
     JUnitTestCase.assertNotNull(annotation.period);
     JUnitTestCase.assertNotNull(annotation.constructorName);
     JUnitTestCase.assertNotNull(annotation.arguments);
   }
   void test_parseArgument_named() {
     NamedExpression expression = ParserTestCase.parse5("parseArgument", "n: x", []);
-    Label name26 = expression.name;
-    JUnitTestCase.assertNotNull(name26);
-    JUnitTestCase.assertNotNull(name26.label);
-    JUnitTestCase.assertNotNull(name26.colon);
+    Label name2 = expression.name;
+    JUnitTestCase.assertNotNull(name2);
+    JUnitTestCase.assertNotNull(name2.label);
+    JUnitTestCase.assertNotNull(name2.colon);
     JUnitTestCase.assertNotNull(expression.expression);
   }
   void test_parseArgument_unnamed() {
     String lexeme = "x";
     SimpleIdentifier identifier = ParserTestCase.parse5("parseArgument", lexeme, []);
     JUnitTestCase.assertEquals(lexeme, identifier.name);
   }
   void test_parseArgumentDefinitionTest() {
     ArgumentDefinitionTest test = ParserTestCase.parse5("parseArgumentDefinitionTest", "?x", []);
     JUnitTestCase.assertNotNull(test.question);
     JUnitTestCase.assertNotNull(test.identifier);
   }
   void test_parseArgumentList_empty() {
     ArgumentList argumentList = ParserTestCase.parse5("parseArgumentList", "()", []);
-    NodeList<Expression> arguments9 = argumentList.arguments;
-    EngineTestCase.assertSize(0, arguments9);
+    NodeList<Expression> arguments2 = argumentList.arguments;
+    EngineTestCase.assertSize(0, arguments2);
   }
   void test_parseArgumentList_mixed() {
     ArgumentList argumentList = ParserTestCase.parse5("parseArgumentList", "(w, x, y: y, z: z)", []);
-    NodeList<Expression> arguments10 = argumentList.arguments;
-    EngineTestCase.assertSize(4, arguments10);
+    NodeList<Expression> arguments2 = argumentList.arguments;
+    EngineTestCase.assertSize(4, arguments2);
   }
   void test_parseArgumentList_noNamed() {
     ArgumentList argumentList = ParserTestCase.parse5("parseArgumentList", "(x, y, z)", []);
-    NodeList<Expression> arguments11 = argumentList.arguments;
-    EngineTestCase.assertSize(3, arguments11);
+    NodeList<Expression> arguments2 = argumentList.arguments;
+    EngineTestCase.assertSize(3, arguments2);
   }
   void test_parseArgumentList_onlyNamed() {
     ArgumentList argumentList = ParserTestCase.parse5("parseArgumentList", "(x: x, y: y)", []);
-    NodeList<Expression> arguments12 = argumentList.arguments;
-    EngineTestCase.assertSize(2, arguments12);
+    NodeList<Expression> arguments2 = argumentList.arguments;
+    EngineTestCase.assertSize(2, arguments2);
   }
   void test_parseAssertStatement() {
     AssertStatement statement = ParserTestCase.parse5("parseAssertStatement", "assert (x);", []);
     JUnitTestCase.assertNotNull(statement.keyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
     JUnitTestCase.assertNotNull(statement.condition);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.semicolon);
   }
   void test_parseAssignableExpression_expression_args_dot() {
     PropertyAccess propertyAccess = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "(x)(y).z");
     FunctionExpressionInvocation invocation = propertyAccess.target as FunctionExpressionInvocation;
     JUnitTestCase.assertNotNull(invocation.function);
-    ArgumentList argumentList10 = invocation.argumentList;
-    JUnitTestCase.assertNotNull(argumentList10);
-    EngineTestCase.assertSize(1, argumentList10.arguments);
+    ArgumentList argumentList2 = invocation.argumentList;
+    JUnitTestCase.assertNotNull(argumentList2);
+    EngineTestCase.assertSize(1, argumentList2.arguments);
     JUnitTestCase.assertNotNull(propertyAccess.operator);
     JUnitTestCase.assertNotNull(propertyAccess.propertyName);
   }
   void test_parseAssignableExpression_expression_dot() {
     PropertyAccess propertyAccess = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "(x).y");
     JUnitTestCase.assertNotNull(propertyAccess.target);
     JUnitTestCase.assertNotNull(propertyAccess.operator);
     JUnitTestCase.assertNotNull(propertyAccess.propertyName);
   }
   void test_parseAssignableExpression_expression_index() {
     IndexExpression expression = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "(x)[y]");
     JUnitTestCase.assertNotNull(expression.array);
     JUnitTestCase.assertNotNull(expression.leftBracket);
     JUnitTestCase.assertNotNull(expression.index);
     JUnitTestCase.assertNotNull(expression.rightBracket);
   }
   void test_parseAssignableExpression_identifier() {
     SimpleIdentifier identifier = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "x");
     JUnitTestCase.assertNotNull(identifier);
   }
   void test_parseAssignableExpression_identifier_args_dot() {
     PropertyAccess propertyAccess = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "x(y).z");
     MethodInvocation invocation = propertyAccess.target as MethodInvocation;
     JUnitTestCase.assertEquals("x", invocation.methodName.name);
-    ArgumentList argumentList11 = invocation.argumentList;
-    JUnitTestCase.assertNotNull(argumentList11);
-    EngineTestCase.assertSize(1, argumentList11.arguments);
+    ArgumentList argumentList2 = invocation.argumentList;
+    JUnitTestCase.assertNotNull(argumentList2);
+    EngineTestCase.assertSize(1, argumentList2.arguments);
     JUnitTestCase.assertNotNull(propertyAccess.operator);
     JUnitTestCase.assertNotNull(propertyAccess.propertyName);
   }
   void test_parseAssignableExpression_identifier_dot() {
     PropertyAccess propertyAccess = ParserTestCase.parse("parseAssignableExpression", <Object> [false], "x.y");
     JUnitTestCase.assertNotNull(propertyAccess.target);
     JUnitTestCase.assertNotNull(propertyAccess.operator);
     JUnitTestCase.assertNotNull(propertyAccess.propertyName);
   }
   void test_parseAssignableExpression_identifier_index() {
@@ skipping 294 matching lines @@
     JUnitTestCase.assertNotNull(constructor.returnType);
     EngineTestCase.assertSize(1, constructor.initializers);
   }
   void test_parseClassMember_field_instance_prefixedType() {
     FieldDeclaration field = ParserTestCase.parse("parseClassMember", <Object> ["C"], "p.A f;");
     JUnitTestCase.assertNull(field.documentationComment);
     EngineTestCase.assertSize(0, field.metadata);
     JUnitTestCase.assertNull(field.keyword);
     VariableDeclarationList list = field.fields;
     JUnitTestCase.assertNotNull(list);
-    NodeList<VariableDeclaration> variables5 = list.variables;
-    EngineTestCase.assertSize(1, variables5);
-    VariableDeclaration variable = variables5[0];
+    NodeList<VariableDeclaration> variables2 = list.variables;
+    EngineTestCase.assertSize(1, variables2);
+    VariableDeclaration variable = variables2[0];
     JUnitTestCase.assertNotNull(variable.name);
   }
   void test_parseClassMember_field_namedGet() {
     FieldDeclaration field = ParserTestCase.parse("parseClassMember", <Object> ["C"], "var get;");
     JUnitTestCase.assertNull(field.documentationComment);
     EngineTestCase.assertSize(0, field.metadata);
     JUnitTestCase.assertNull(field.keyword);
     VariableDeclarationList list = field.fields;
     JUnitTestCase.assertNotNull(list);
-    NodeList<VariableDeclaration> variables6 = list.variables;
-    EngineTestCase.assertSize(1, variables6);
-    VariableDeclaration variable = variables6[0];
+    NodeList<VariableDeclaration> variables2 = list.variables;
+    EngineTestCase.assertSize(1, variables2);
+    VariableDeclaration variable = variables2[0];
     JUnitTestCase.assertNotNull(variable.name);
   }
   void test_parseClassMember_field_namedOperator() {
     FieldDeclaration field = ParserTestCase.parse("parseClassMember", <Object> ["C"], "var operator;");
     JUnitTestCase.assertNull(field.documentationComment);
     EngineTestCase.assertSize(0, field.metadata);
     JUnitTestCase.assertNull(field.keyword);
     VariableDeclarationList list = field.fields;
     JUnitTestCase.assertNotNull(list);
-    NodeList<VariableDeclaration> variables7 = list.variables;
-    EngineTestCase.assertSize(1, variables7);
-    VariableDeclaration variable = variables7[0];
+    NodeList<VariableDeclaration> variables2 = list.variables;
+    EngineTestCase.assertSize(1, variables2);
+    VariableDeclaration variable = variables2[0];
     JUnitTestCase.assertNotNull(variable.name);
   }
   void test_parseClassMember_field_namedSet() {
     FieldDeclaration field = ParserTestCase.parse("parseClassMember", <Object> ["C"], "var set;");
     JUnitTestCase.assertNull(field.documentationComment);
     EngineTestCase.assertSize(0, field.metadata);
     JUnitTestCase.assertNull(field.keyword);
     VariableDeclarationList list = field.fields;
     JUnitTestCase.assertNotNull(list);
-    NodeList<VariableDeclaration> variables8 = list.variables;
-    EngineTestCase.assertSize(1, variables8);
-    VariableDeclaration variable = variables8[0];
+    NodeList<VariableDeclaration> variables2 = list.variables;
+    EngineTestCase.assertSize(1, variables2);
+    VariableDeclaration variable = variables2[0];
     JUnitTestCase.assertNotNull(variable.name);
   }
   void test_parseClassMember_getter_void() {
     MethodDeclaration method = ParserTestCase.parse("parseClassMember", <Object> ["C"], "void get g {}");
     JUnitTestCase.assertNull(method.documentationComment);
     JUnitTestCase.assertNull(method.externalKeyword);
     JUnitTestCase.assertNull(method.modifierKeyword);
     JUnitTestCase.assertNotNull(method.propertyKeyword);
     JUnitTestCase.assertNotNull(method.returnType);
     JUnitTestCase.assertNotNull(method.name);
@@ skipping 190 matching lines @@
     JUnitTestCase.assertNotNull(constructor.returnType);
     JUnitTestCase.assertNull(constructor.period);
     JUnitTestCase.assertNull(constructor.name);
     JUnitTestCase.assertNotNull(constructor.parameters);
     JUnitTestCase.assertNotNull(constructor.separator);
     EngineTestCase.assertSize(0, constructor.initializers);
     JUnitTestCase.assertNotNull(constructor.redirectedConstructor);
     JUnitTestCase.assertNotNull(constructor.body);
   }
   void test_parseClassTypeAlias() {
-    Token token5 = TokenFactory.token(Keyword.TYPEDEF);
-    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token5], "A = B;");
+    Token token2 = TokenFactory.token(Keyword.TYPEDEF);
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token2], "A = B;");
     JUnitTestCase.assertNotNull(classTypeAlias.keyword);
     JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.equals);
     JUnitTestCase.assertNull(classTypeAlias.abstractKeyword);
     JUnitTestCase.assertNotNullMsg("B", classTypeAlias.superclass.name.name);
     JUnitTestCase.assertNull(classTypeAlias.withClause);
     JUnitTestCase.assertNull(classTypeAlias.implementsClause);
     JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
   }
   void test_parseClassTypeAlias_abstract() {
-    Token token6 = TokenFactory.token(Keyword.TYPEDEF);
-    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token6], "A = abstract B;");
+    Token token2 = TokenFactory.token(Keyword.TYPEDEF);
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token2], "A = abstract B;");
     JUnitTestCase.assertNotNull(classTypeAlias.keyword);
     JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.equals);
     JUnitTestCase.assertNotNull(classTypeAlias.abstractKeyword);
     JUnitTestCase.assertNotNullMsg("B", classTypeAlias.superclass.name.name);
     JUnitTestCase.assertNull(classTypeAlias.withClause);
     JUnitTestCase.assertNull(classTypeAlias.implementsClause);
     JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
   }
   void test_parseClassTypeAlias_implements() {
-    Token token7 = TokenFactory.token(Keyword.TYPEDEF);
-    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token7], "A = B implements C;");
+    Token token2 = TokenFactory.token(Keyword.TYPEDEF);
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token2], "A = B implements C;");
     JUnitTestCase.assertNotNull(classTypeAlias.keyword);
     JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.equals);
     JUnitTestCase.assertNull(classTypeAlias.abstractKeyword);
     JUnitTestCase.assertNotNullMsg("B", classTypeAlias.superclass.name.name);
     JUnitTestCase.assertNull(classTypeAlias.withClause);
     JUnitTestCase.assertNotNull(classTypeAlias.implementsClause);
     JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
   }
   void test_parseClassTypeAlias_with() {
-    Token token8 = TokenFactory.token(Keyword.TYPEDEF);
-    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token8], "A = B with C;");
+    Token token2 = TokenFactory.token(Keyword.TYPEDEF);
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token2], "A = B with C;");
     JUnitTestCase.assertNotNull(classTypeAlias.keyword);
     JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.equals);
     JUnitTestCase.assertNull(classTypeAlias.abstractKeyword);
     JUnitTestCase.assertNotNullMsg("B", classTypeAlias.superclass.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.withClause);
     JUnitTestCase.assertNull(classTypeAlias.implementsClause);
     JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
   }
   void test_parseClassTypeAlias_with_implements() {
-    Token token9 = TokenFactory.token(Keyword.TYPEDEF);
-    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token9], "A = B with C implements D;");
+    Token token2 = TokenFactory.token(Keyword.TYPEDEF);
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token2], "A = B with C implements D;");
     JUnitTestCase.assertNotNull(classTypeAlias.keyword);
     JUnitTestCase.assertEquals("A", classTypeAlias.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.equals);
     JUnitTestCase.assertNull(classTypeAlias.abstractKeyword);
     JUnitTestCase.assertNotNullMsg("B", classTypeAlias.superclass.name.name);
     JUnitTestCase.assertNotNull(classTypeAlias.withClause);
     JUnitTestCase.assertNotNull(classTypeAlias.implementsClause);
     JUnitTestCase.assertNotNull(classTypeAlias.semicolon);
   }
   void test_parseCombinators_h() {
@@ skipping 69 matching lines @@
     EngineTestCase.assertSize(2, commentAndMetadata.metadata);
   }
   void test_parseCommentAndMetadata_none() {
     CommentAndMetadata commentAndMetadata = ParserTestCase.parse5("parseCommentAndMetadata", "void", []);
     JUnitTestCase.assertNull(commentAndMetadata.comment);
     EngineTestCase.assertSize(0, commentAndMetadata.metadata);
   }
   void test_parseCommentReference_new_prefixed() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["new a.b", 7], "");
     PrefixedIdentifier prefixedIdentifier = EngineTestCase.assertInstanceOf(PrefixedIdentifier, reference.identifier);
-    SimpleIdentifier prefix10 = prefixedIdentifier.prefix;
-    JUnitTestCase.assertNotNull(prefix10.token);
-    JUnitTestCase.assertEquals("a", prefix10.name);
-    JUnitTestCase.assertEquals(11, prefix10.offset);
+    SimpleIdentifier prefix2 = prefixedIdentifier.prefix;
+    JUnitTestCase.assertNotNull(prefix2.token);
+    JUnitTestCase.assertEquals("a", prefix2.name);
+    JUnitTestCase.assertEquals(11, prefix2.offset);
     JUnitTestCase.assertNotNull(prefixedIdentifier.period);
-    SimpleIdentifier identifier22 = prefixedIdentifier.identifier;
-    JUnitTestCase.assertNotNull(identifier22.token);
-    JUnitTestCase.assertEquals("b", identifier22.name);
-    JUnitTestCase.assertEquals(13, identifier22.offset);
+    SimpleIdentifier identifier2 = prefixedIdentifier.identifier;
+    JUnitTestCase.assertNotNull(identifier2.token);
+    JUnitTestCase.assertEquals("b", identifier2.name);
+    JUnitTestCase.assertEquals(13, identifier2.offset);
   }
   void test_parseCommentReference_new_simple() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["new a", 5], "");
-    SimpleIdentifier identifier23 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
-    JUnitTestCase.assertNotNull(identifier23.token);
-    JUnitTestCase.assertEquals("a", identifier23.name);
-    JUnitTestCase.assertEquals(9, identifier23.offset);
+    SimpleIdentifier identifier2 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
+    JUnitTestCase.assertNotNull(identifier2.token);
+    JUnitTestCase.assertEquals("a", identifier2.name);
+    JUnitTestCase.assertEquals(9, identifier2.offset);
   }
   void test_parseCommentReference_prefixed() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["a.b", 7], "");
     PrefixedIdentifier prefixedIdentifier = EngineTestCase.assertInstanceOf(PrefixedIdentifier, reference.identifier);
-    SimpleIdentifier prefix11 = prefixedIdentifier.prefix;
-    JUnitTestCase.assertNotNull(prefix11.token);
-    JUnitTestCase.assertEquals("a", prefix11.name);
-    JUnitTestCase.assertEquals(7, prefix11.offset);
+    SimpleIdentifier prefix2 = prefixedIdentifier.prefix;
+    JUnitTestCase.assertNotNull(prefix2.token);
+    JUnitTestCase.assertEquals("a", prefix2.name);
+    JUnitTestCase.assertEquals(7, prefix2.offset);
     JUnitTestCase.assertNotNull(prefixedIdentifier.period);
-    SimpleIdentifier identifier24 = prefixedIdentifier.identifier;
-    JUnitTestCase.assertNotNull(identifier24.token);
-    JUnitTestCase.assertEquals("b", identifier24.name);
-    JUnitTestCase.assertEquals(9, identifier24.offset);
+    SimpleIdentifier identifier2 = prefixedIdentifier.identifier;
+    JUnitTestCase.assertNotNull(identifier2.token);
+    JUnitTestCase.assertEquals("b", identifier2.name);
+    JUnitTestCase.assertEquals(9, identifier2.offset);
   }
   void test_parseCommentReference_simple() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["a", 5], "");
-    SimpleIdentifier identifier25 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
-    JUnitTestCase.assertNotNull(identifier25.token);
-    JUnitTestCase.assertEquals("a", identifier25.name);
-    JUnitTestCase.assertEquals(5, identifier25.offset);
+    SimpleIdentifier identifier2 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
+    JUnitTestCase.assertNotNull(identifier2.token);
+    JUnitTestCase.assertEquals("a", identifier2.name);
+    JUnitTestCase.assertEquals(5, identifier2.offset);
   }
   void test_parseCommentReferences_multiLine() {
     List<Token> tokens = <Token> [new StringToken(TokenType.MULTI_LINE_COMMENT, "/** xxx [a] yyy [b] zzz */", 3)];
     List<CommentReference> references = ParserTestCase.parse("parseCommentReferences", <Object> [tokens], "");
     EngineTestCase.assertSize(2, references);
     CommentReference reference = references[0];
     JUnitTestCase.assertNotNull(reference);
     JUnitTestCase.assertNotNull(reference.identifier);
     JUnitTestCase.assertEquals(12, reference.offset);
     reference = references[1];
@@ skipping 508 matching lines @@
     JUnitTestCase.assertNotNull(invocation.argumentList);
   }
   void test_parseExtendsClause() {
     ExtendsClause clause = ParserTestCase.parse5("parseExtendsClause", "extends B", []);
     JUnitTestCase.assertNotNull(clause.keyword);
     JUnitTestCase.assertNotNull(clause.superclass);
     EngineTestCase.assertInstanceOf(TypeName, clause.superclass);
   }
   void test_parseFinalConstVarOrType_const_noType() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "const");
-    Token keyword32 = result.keyword;
-    JUnitTestCase.assertNotNull(keyword32);
-    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword32.type);
-    JUnitTestCase.assertEquals(Keyword.CONST, ((keyword32 as KeywordToken)).keyword);
+    Token keyword2 = result.keyword;
+    JUnitTestCase.assertNotNull(keyword2);
+    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword2.type);
+    JUnitTestCase.assertEquals(Keyword.CONST, ((keyword2 as KeywordToken)).keyword);
     JUnitTestCase.assertNull(result.type);
   }
   void test_parseFinalConstVarOrType_const_type() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "const A a");
-    Token keyword33 = result.keyword;
-    JUnitTestCase.assertNotNull(keyword33);
-    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword33.type);
-    JUnitTestCase.assertEquals(Keyword.CONST, ((keyword33 as KeywordToken)).keyword);
+    Token keyword2 = result.keyword;
+    JUnitTestCase.assertNotNull(keyword2);
+    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword2.type);
+    JUnitTestCase.assertEquals(Keyword.CONST, ((keyword2 as KeywordToken)).keyword);
     JUnitTestCase.assertNotNull(result.type);
   }
   void test_parseFinalConstVarOrType_final_noType() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "final");
-    Token keyword34 = result.keyword;
-    JUnitTestCase.assertNotNull(keyword34);
-    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword34.type);
-    JUnitTestCase.assertEquals(Keyword.FINAL, ((keyword34 as KeywordToken)).keyword);
+    Token keyword2 = result.keyword;
+    JUnitTestCase.assertNotNull(keyword2);
+    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword2.type);
+    JUnitTestCase.assertEquals(Keyword.FINAL, ((keyword2 as KeywordToken)).keyword);
     JUnitTestCase.assertNull(result.type);
   }
   void test_parseFinalConstVarOrType_final_type() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "final A a");
-    Token keyword35 = result.keyword;
-    JUnitTestCase.assertNotNull(keyword35);
-    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword35.type);
-    JUnitTestCase.assertEquals(Keyword.FINAL, ((keyword35 as KeywordToken)).keyword);
+    Token keyword2 = result.keyword;
+    JUnitTestCase.assertNotNull(keyword2);
+    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword2.type);
+    JUnitTestCase.assertEquals(Keyword.FINAL, ((keyword2 as KeywordToken)).keyword);
     JUnitTestCase.assertNotNull(result.type);
   }
   void test_parseFinalConstVarOrType_type_parameterized() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "A<B> a");
     JUnitTestCase.assertNull(result.keyword);
     JUnitTestCase.assertNotNull(result.type);
   }
   void test_parseFinalConstVarOrType_type_prefixed() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "p.A a");
     JUnitTestCase.assertNull(result.keyword);
     JUnitTestCase.assertNotNull(result.type);
   }
   void test_parseFinalConstVarOrType_type_prefixedAndParameterized() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "p.A<B> a");
     JUnitTestCase.assertNull(result.keyword);
     JUnitTestCase.assertNotNull(result.type);
   }
   void test_parseFinalConstVarOrType_type_simple() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "A a");
     JUnitTestCase.assertNull(result.keyword);
     JUnitTestCase.assertNotNull(result.type);
   }
   void test_parseFinalConstVarOrType_var() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "var");
-    Token keyword36 = result.keyword;
-    JUnitTestCase.assertNotNull(keyword36);
-    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword36.type);
-    JUnitTestCase.assertEquals(Keyword.VAR, ((keyword36 as KeywordToken)).keyword);
+    Token keyword2 = result.keyword;
+    JUnitTestCase.assertNotNull(keyword2);
+    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword2.type);
+    JUnitTestCase.assertEquals(Keyword.VAR, ((keyword2 as KeywordToken)).keyword);
     JUnitTestCase.assertNull(result.type);
   }
   void test_parseFormalParameter_final_withType_named() {
     ParameterKind kind = ParameterKind.NAMED;
     DefaultFormalParameter parameter = ParserTestCase.parse("parseFormalParameter", <Object> [kind], "final A a : null");
     SimpleFormalParameter simpleParameter = parameter.parameter as SimpleFormalParameter;
     JUnitTestCase.assertNotNull(simpleParameter.identifier);
     JUnitTestCase.assertNotNull(simpleParameter.keyword);
     JUnitTestCase.assertNotNull(simpleParameter.type);
     JUnitTestCase.assertEquals(kind, simpleParameter.kind);
@@ skipping 234 matching lines @@
     JUnitTestCase.assertNotNull(statement.condition);
     JUnitTestCase.assertNotNull(statement.rightSeparator);
     EngineTestCase.assertSize(1, statement.updaters);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
   void test_parseForStatement_loop_i() {
     ForStatement statement = ParserTestCase.parse5("parseForStatement", "for (var i = 0;;) {}", []);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
-    VariableDeclarationList variables9 = statement.variables;
-    JUnitTestCase.assertNotNull(variables9);
-    EngineTestCase.assertSize(0, variables9.metadata);
-    EngineTestCase.assertSize(1, variables9.variables);
+    VariableDeclarationList variables2 = statement.variables;
+    JUnitTestCase.assertNotNull(variables2);
+    EngineTestCase.assertSize(0, variables2.metadata);
+    EngineTestCase.assertSize(1, variables2.variables);
     JUnitTestCase.assertNull(statement.initialization);
     JUnitTestCase.assertNotNull(statement.leftSeparator);
     JUnitTestCase.assertNull(statement.condition);
     JUnitTestCase.assertNotNull(statement.rightSeparator);
     EngineTestCase.assertSize(0, statement.updaters);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
   void test_parseForStatement_loop_i_withMetadata() {
     ForStatement statement = ParserTestCase.parse5("parseForStatement", "for (@A var i = 0;;) {}", []);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
-    VariableDeclarationList variables10 = statement.variables;
-    JUnitTestCase.assertNotNull(variables10);
-    EngineTestCase.assertSize(1, variables10.metadata);
-    EngineTestCase.assertSize(1, variables10.variables);
+    VariableDeclarationList variables2 = statement.variables;
+    JUnitTestCase.assertNotNull(variables2);
+    EngineTestCase.assertSize(1, variables2.metadata);
+    EngineTestCase.assertSize(1, variables2.variables);
     JUnitTestCase.assertNull(statement.initialization);
     JUnitTestCase.assertNotNull(statement.leftSeparator);
     JUnitTestCase.assertNull(statement.condition);
     JUnitTestCase.assertNotNull(statement.rightSeparator);
     EngineTestCase.assertSize(0, statement.updaters);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
   void test_parseForStatement_loop_ic() {
     ForStatement statement = ParserTestCase.parse5("parseForStatement", "for (var i = 0; i < count;) {}", []);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
-    VariableDeclarationList variables11 = statement.variables;
-    JUnitTestCase.assertNotNull(variables11);
-    EngineTestCase.assertSize(1, variables11.variables);
+    VariableDeclarationList variables2 = statement.variables;
+    JUnitTestCase.assertNotNull(variables2);
+    EngineTestCase.assertSize(1, variables2.variables);
     JUnitTestCase.assertNull(statement.initialization);
     JUnitTestCase.assertNotNull(statement.leftSeparator);
     JUnitTestCase.assertNotNull(statement.condition);
     JUnitTestCase.assertNotNull(statement.rightSeparator);
     EngineTestCase.assertSize(0, statement.updaters);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
   void test_parseForStatement_loop_icu() {
     ForStatement statement = ParserTestCase.parse5("parseForStatement", "for (var i = 0; i < count; i++) {}", []);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
-    VariableDeclarationList variables12 = statement.variables;
-    JUnitTestCase.assertNotNull(variables12);
-    EngineTestCase.assertSize(1, variables12.variables);
+    VariableDeclarationList variables2 = statement.variables;
+    JUnitTestCase.assertNotNull(variables2);
+    EngineTestCase.assertSize(1, variables2.variables);
     JUnitTestCase.assertNull(statement.initialization);
     JUnitTestCase.assertNotNull(statement.leftSeparator);
     JUnitTestCase.assertNotNull(statement.condition);
     JUnitTestCase.assertNotNull(statement.rightSeparator);
     EngineTestCase.assertSize(1, statement.updaters);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
   void test_parseForStatement_loop_iicuu() {
     ForStatement statement = ParserTestCase.parse5("parseForStatement", "for (int i = 0, j = count; i < j; i++, j--) {}", []);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
-    VariableDeclarationList variables13 = statement.variables;
-    JUnitTestCase.assertNotNull(variables13);
-    EngineTestCase.assertSize(2, variables13.variables);
+    VariableDeclarationList variables2 = statement.variables;
+    JUnitTestCase.assertNotNull(variables2);
+    EngineTestCase.assertSize(2, variables2.variables);
     JUnitTestCase.assertNull(statement.initialization);
     JUnitTestCase.assertNotNull(statement.leftSeparator);
     JUnitTestCase.assertNotNull(statement.condition);
     JUnitTestCase.assertNotNull(statement.rightSeparator);
     EngineTestCase.assertSize(2, statement.updaters);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
   void test_parseForStatement_loop_iu() {
     ForStatement statement = ParserTestCase.parse5("parseForStatement", "for (var i = 0;; i++) {}", []);
     JUnitTestCase.assertNotNull(statement.forKeyword);
     JUnitTestCase.assertNotNull(statement.leftParenthesis);
-    VariableDeclarationList variables14 = statement.variables;
-    JUnitTestCase.assertNotNull(variables14);
-    EngineTestCase.assertSize(1, variables14.variables);
+    VariableDeclarationList variables2 = statement.variables;
+    JUnitTestCase.assertNotNull(variables2);
+    EngineTestCase.assertSize(1, variables2.variables);
     JUnitTestCase.assertNull(statement.initialization);
     JUnitTestCase.assertNotNull(statement.leftSeparator);
     JUnitTestCase.assertNull(statement.condition);
     JUnitTestCase.assertNotNull(statement.rightSeparator);
     EngineTestCase.assertSize(1, statement.updaters);
     JUnitTestCase.assertNotNull(statement.rightParenthesis);
     JUnitTestCase.assertNotNull(statement.body);
   }
   void test_parseForStatement_loop_u() {
     ForStatement statement = ParserTestCase.parse5("parseForStatement", "for (;; i++) {}", []);
@@ skipping 222 matching lines @@
     JUnitTestCase.assertNull(directive.prefix);
     EngineTestCase.assertSize(1, directive.combinators);
     JUnitTestCase.assertNotNull(directive.semicolon);
   }
   void test_parseInitializedIdentifierList_type() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     Token staticKeyword = TokenFactory.token(Keyword.STATIC);
     TypeName type = new TypeName.full(new SimpleIdentifier.full(null), null);
     FieldDeclaration declaration = ParserTestCase.parse("parseInitializedIdentifierList", <Object> [commentAndMetadata(comment, []), staticKeyword, null, type], "a = 1, b, c = 3;");
     JUnitTestCase.assertEquals(comment, declaration.documentationComment);
-    VariableDeclarationList fields4 = declaration.fields;
-    JUnitTestCase.assertNotNull(fields4);
-    JUnitTestCase.assertNull(fields4.keyword);
-    JUnitTestCase.assertEquals(type, fields4.type);
-    EngineTestCase.assertSize(3, fields4.variables);
+    VariableDeclarationList fields2 = declaration.fields;
+    JUnitTestCase.assertNotNull(fields2);
+    JUnitTestCase.assertNull(fields2.keyword);
+    JUnitTestCase.assertEquals(type, fields2.type);
+    EngineTestCase.assertSize(3, fields2.variables);
     JUnitTestCase.assertEquals(staticKeyword, declaration.keyword);
     JUnitTestCase.assertNotNull(declaration.semicolon);
   }
   void test_parseInitializedIdentifierList_var() {
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     Token staticKeyword = TokenFactory.token(Keyword.STATIC);
     Token varKeyword = TokenFactory.token(Keyword.VAR);
     FieldDeclaration declaration = ParserTestCase.parse("parseInitializedIdentifierList", <Object> [commentAndMetadata(comment, []), staticKeyword, varKeyword, null], "a = 1, b, c = 3;");
     JUnitTestCase.assertEquals(comment, declaration.documentationComment);
-    VariableDeclarationList fields5 = declaration.fields;
-    JUnitTestCase.assertNotNull(fields5);
-    JUnitTestCase.assertEquals(varKeyword, fields5.keyword);
-    JUnitTestCase.assertNull(fields5.type);
-    EngineTestCase.assertSize(3, fields5.variables);
+    VariableDeclarationList fields2 = declaration.fields;
+    JUnitTestCase.assertNotNull(fields2);
+    JUnitTestCase.assertEquals(varKeyword, fields2.keyword);
+    JUnitTestCase.assertNull(fields2.type);
+    EngineTestCase.assertSize(3, fields2.variables);
     JUnitTestCase.assertEquals(staticKeyword, declaration.keyword);
     JUnitTestCase.assertNotNull(declaration.semicolon);
   }
   void test_parseInstanceCreationExpression_qualifiedType() {
-    Token token10 = TokenFactory.token(Keyword.NEW);
-    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token10], "A.B()");
-    JUnitTestCase.assertEquals(token10, expression.keyword);
+    Token token2 = TokenFactory.token(Keyword.NEW);
+    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token2], "A.B()");
+    JUnitTestCase.assertEquals(token2, expression.keyword);
     ConstructorName name = expression.constructorName;
     JUnitTestCase.assertNotNull(name);
     JUnitTestCase.assertNotNull(name.type);
     JUnitTestCase.assertNull(name.period);
     JUnitTestCase.assertNull(name.name);
     JUnitTestCase.assertNotNull(expression.argumentList);
   }
   void test_parseInstanceCreationExpression_qualifiedType_named() {
-    Token token11 = TokenFactory.token(Keyword.NEW);
-    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token11], "A.B.c()");
-    JUnitTestCase.assertEquals(token11, expression.keyword);
+    Token token2 = TokenFactory.token(Keyword.NEW);
+    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token2], "A.B.c()");
+    JUnitTestCase.assertEquals(token2, expression.keyword);
     ConstructorName name = expression.constructorName;
     JUnitTestCase.assertNotNull(name);
     JUnitTestCase.assertNotNull(name.type);
     JUnitTestCase.assertNotNull(name.period);
     JUnitTestCase.assertNotNull(name.name);
     JUnitTestCase.assertNotNull(expression.argumentList);
   }
   void test_parseInstanceCreationExpression_type() {
-    Token token12 = TokenFactory.token(Keyword.NEW);
-    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token12], "A()");
-    JUnitTestCase.assertEquals(token12, expression.keyword);
+    Token token2 = TokenFactory.token(Keyword.NEW);
+    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token2], "A()");
+    JUnitTestCase.assertEquals(token2, expression.keyword);
     ConstructorName name = expression.constructorName;
     JUnitTestCase.assertNotNull(name);
     JUnitTestCase.assertNotNull(name.type);
     JUnitTestCase.assertNull(name.period);
     JUnitTestCase.assertNull(name.name);
     JUnitTestCase.assertNotNull(expression.argumentList);
   }
   void test_parseInstanceCreationExpression_type_named() {
-    Token token13 = TokenFactory.token(Keyword.NEW);
-    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token13], "A<B>.c()");
-    JUnitTestCase.assertEquals(token13, expression.keyword);
+    Token token2 = TokenFactory.token(Keyword.NEW);
+    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token2], "A<B>.c()");
+    JUnitTestCase.assertEquals(token2, expression.keyword);
     ConstructorName name = expression.constructorName;
     JUnitTestCase.assertNotNull(name);
     JUnitTestCase.assertNotNull(name.type);
     JUnitTestCase.assertNotNull(name.period);
     JUnitTestCase.assertNotNull(name.name);
     JUnitTestCase.assertNotNull(expression.argumentList);
   }
   void test_parseLibraryDirective() {
     LibraryDirective directive = ParserTestCase.parse("parseLibraryDirective", <Object> [emptyCommentAndMetadata()], "library l;");
     JUnitTestCase.assertNotNull(directive.libraryToken);
     JUnitTestCase.assertNotNull(directive.name);
     JUnitTestCase.assertNotNull(directive.semicolon);
   }
   void test_parseLibraryIdentifier_multiple() {
     String name = "a.b.c";
     LibraryIdentifier identifier = ParserTestCase.parse5("parseLibraryIdentifier", name, []);
     JUnitTestCase.assertEquals(name, identifier.name);
   }
   void test_parseLibraryIdentifier_single() {
     String name = "a";
     LibraryIdentifier identifier = ParserTestCase.parse5("parseLibraryIdentifier", name, []);
     JUnitTestCase.assertEquals(name, identifier.name);
   }
   void test_parseListLiteral_empty_oneToken() {
-    Token token14 = TokenFactory.token(Keyword.CONST);
+    Token token2 = TokenFactory.token(Keyword.CONST);
     TypeArgumentList typeArguments = new TypeArgumentList.full(null, null, null);
-    ListLiteral literal = ParserTestCase.parse("parseListLiteral", <Object> [token14, typeArguments], "[]");
-    JUnitTestCase.assertEquals(token14, literal.modifier);
+    ListLiteral literal = ParserTestCase.parse("parseListLiteral", <Object> [token2, typeArguments], "[]");
+    JUnitTestCase.assertEquals(token2, literal.modifier);
     JUnitTestCase.assertEquals(typeArguments, literal.typeArguments);
     JUnitTestCase.assertNotNull(literal.leftBracket);
     EngineTestCase.assertSize(0, literal.elements);
     JUnitTestCase.assertNotNull(literal.rightBracket);
   }
   void test_parseListLiteral_empty_twoTokens() {
-    Token token15 = TokenFactory.token(Keyword.CONST);
+    Token token2 = TokenFactory.token(Keyword.CONST);
     TypeArgumentList typeArguments = new TypeArgumentList.full(null, null, null);
-    ListLiteral literal = ParserTestCase.parse("parseListLiteral", <Object> [token15, typeArguments], "[ ]");
-    JUnitTestCase.assertEquals(token15, literal.modifier);
+    ListLiteral literal = ParserTestCase.parse("parseListLiteral", <Object> [token2, typeArguments], "[ ]");
+    JUnitTestCase.assertEquals(token2, literal.modifier);
     JUnitTestCase.assertEquals(typeArguments, literal.typeArguments);
     JUnitTestCase.assertNotNull(literal.leftBracket);
     EngineTestCase.assertSize(0, literal.elements);
     JUnitTestCase.assertNotNull(literal.rightBracket);
   }
   void test_parseListLiteral_multiple() {
     ListLiteral literal = ParserTestCase.parse("parseListLiteral", <Object> [null, null], "[1, 2, 3]");
     JUnitTestCase.assertNull(literal.modifier);
     JUnitTestCase.assertNull(literal.typeArguments);
     JUnitTestCase.assertNotNull(literal.leftBracket);
@@ skipping 48 matching lines @@
     JUnitTestCase.assertNotNull(expression.rightOperand);
   }
   void test_parseLogicalOrExpression() {
     BinaryExpression expression = ParserTestCase.parse5("parseLogicalOrExpression", "x || y", []);
     JUnitTestCase.assertNotNull(expression.leftOperand);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.BAR_BAR, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.rightOperand);
   }
   void test_parseMapLiteral_empty() {
-    Token token16 = TokenFactory.token(Keyword.CONST);
+    Token token2 = TokenFactory.token(Keyword.CONST);
     TypeArgumentList typeArguments = new TypeArgumentList.full(null, null, null);
-    MapLiteral literal = ParserTestCase.parse("parseMapLiteral", <Object> [token16, typeArguments], "{}");
-    JUnitTestCase.assertEquals(token16, literal.modifier);
+    MapLiteral literal = ParserTestCase.parse("parseMapLiteral", <Object> [token2, typeArguments], "{}");
+    JUnitTestCase.assertEquals(token2, literal.modifier);
     JUnitTestCase.assertEquals(typeArguments, literal.typeArguments);
     JUnitTestCase.assertNotNull(literal.leftBracket);
     EngineTestCase.assertSize(0, literal.entries);
     JUnitTestCase.assertNotNull(literal.rightBracket);
   }
   void test_parseMapLiteral_multiple() {
     MapLiteral literal = ParserTestCase.parse("parseMapLiteral", <Object> [null, null], "{'a' : b, 'x' : y}");
     JUnitTestCase.assertNotNull(literal.leftBracket);
     EngineTestCase.assertSize(2, literal.entries);
     JUnitTestCase.assertNotNull(literal.rightBracket);
@@ skipping 665 matching lines @@
     JUnitTestCase.assertNull(clause.comma);
     JUnitTestCase.assertNull(clause.stackTraceParameter);
     JUnitTestCase.assertNotNull(clause.body);
     JUnitTestCase.assertNull(statement.finallyKeyword);
     JUnitTestCase.assertNull(statement.finallyClause);
   }
   void test_parseTryStatement_catch_finally() {
     TryStatement statement = ParserTestCase.parse5("parseTryStatement", "try {} catch (e, s) {} finally {}", []);
     JUnitTestCase.assertNotNull(statement.tryKeyword);
     JUnitTestCase.assertNotNull(statement.body);
-    NodeList<CatchClause> catchClauses3 = statement.catchClauses;
-    EngineTestCase.assertSize(1, catchClauses3);
-    CatchClause clause = catchClauses3[0];
+    NodeList<CatchClause> catchClauses2 = statement.catchClauses;
+    EngineTestCase.assertSize(1, catchClauses2);
+    CatchClause clause = catchClauses2[0];
     JUnitTestCase.assertNull(clause.onKeyword);
     JUnitTestCase.assertNull(clause.exceptionType);
     JUnitTestCase.assertNotNull(clause.catchKeyword);
     JUnitTestCase.assertNotNull(clause.exceptionParameter);
     JUnitTestCase.assertNotNull(clause.comma);
     JUnitTestCase.assertNotNull(clause.stackTraceParameter);
     JUnitTestCase.assertNotNull(clause.body);
     JUnitTestCase.assertNotNull(statement.finallyKeyword);
     JUnitTestCase.assertNotNull(statement.finallyClause);
   }
@@ skipping 10 matching lines @@
     JUnitTestCase.assertNotNull(statement.tryKeyword);
     JUnitTestCase.assertNotNull(statement.body);
     EngineTestCase.assertSize(3, statement.catchClauses);
     JUnitTestCase.assertNull(statement.finallyKeyword);
     JUnitTestCase.assertNull(statement.finallyClause);
   }
   void test_parseTryStatement_on() {
     TryStatement statement = ParserTestCase.parse5("parseTryStatement", "try {} on Error {}", []);
     JUnitTestCase.assertNotNull(statement.tryKeyword);
     JUnitTestCase.assertNotNull(statement.body);
-    NodeList<CatchClause> catchClauses4 = statement.catchClauses;
-    EngineTestCase.assertSize(1, catchClauses4);
-    CatchClause clause = catchClauses4[0];
+    NodeList<CatchClause> catchClauses2 = statement.catchClauses;
+    EngineTestCase.assertSize(1, catchClauses2);
+    CatchClause clause = catchClauses2[0];
     JUnitTestCase.assertNotNull(clause.onKeyword);
     JUnitTestCase.assertNotNull(clause.exceptionType);
     JUnitTestCase.assertNull(clause.catchKeyword);
     JUnitTestCase.assertNull(clause.exceptionParameter);
     JUnitTestCase.assertNull(clause.comma);
     JUnitTestCase.assertNull(clause.stackTraceParameter);
     JUnitTestCase.assertNotNull(clause.body);
     JUnitTestCase.assertNull(statement.finallyKeyword);
     JUnitTestCase.assertNull(statement.finallyClause);
   }
   void test_parseTryStatement_on_catch() {
     TryStatement statement = ParserTestCase.parse5("parseTryStatement", "try {} on Error catch (e, s) {}", []);
     JUnitTestCase.assertNotNull(statement.tryKeyword);
     JUnitTestCase.assertNotNull(statement.body);
-    NodeList<CatchClause> catchClauses5 = statement.catchClauses;
-    EngineTestCase.assertSize(1, catchClauses5);
-    CatchClause clause = catchClauses5[0];
+    NodeList<CatchClause> catchClauses2 = statement.catchClauses;
+    EngineTestCase.assertSize(1, catchClauses2);
+    CatchClause clause = catchClauses2[0];
     JUnitTestCase.assertNotNull(clause.onKeyword);
     JUnitTestCase.assertNotNull(clause.exceptionType);
     JUnitTestCase.assertNotNull(clause.catchKeyword);
     JUnitTestCase.assertNotNull(clause.exceptionParameter);
     JUnitTestCase.assertNotNull(clause.comma);
     JUnitTestCase.assertNotNull(clause.stackTraceParameter);
     JUnitTestCase.assertNotNull(clause.body);
     JUnitTestCase.assertNull(statement.finallyKeyword);
     JUnitTestCase.assertNull(statement.finallyClause);
   }
   void test_parseTryStatement_on_catch_finally() {
     TryStatement statement = ParserTestCase.parse5("parseTryStatement", "try {} on Error catch (e, s) {} finally {}", []);
     JUnitTestCase.assertNotNull(statement.tryKeyword);
     JUnitTestCase.assertNotNull(statement.body);
-    NodeList<CatchClause> catchClauses6 = statement.catchClauses;
-    EngineTestCase.assertSize(1, catchClauses6);
-    CatchClause clause = catchClauses6[0];
+    NodeList<CatchClause> catchClauses2 = statement.catchClauses;
+    EngineTestCase.assertSize(1, catchClauses2);
+    CatchClause clause = catchClauses2[0];
     JUnitTestCase.assertNotNull(clause.onKeyword);
     JUnitTestCase.assertNotNull(clause.exceptionType);
     JUnitTestCase.assertNotNull(clause.catchKeyword);
     JUnitTestCase.assertNotNull(clause.exceptionParameter);
     JUnitTestCase.assertNotNull(clause.comma);
     JUnitTestCase.assertNotNull(clause.stackTraceParameter);
     JUnitTestCase.assertNotNull(clause.body);
     JUnitTestCase.assertNotNull(statement.finallyKeyword);
     JUnitTestCase.assertNotNull(statement.finallyClause);
   }
@@ skipping 158 matching lines @@
     PrefixExpression operand = innerExpression as PrefixExpression;
     JUnitTestCase.assertNotNull(operand.operator);
     JUnitTestCase.assertEquals(TokenType.MINUS, operand.operator.type);
     JUnitTestCase.assertNotNull(operand.operand);
   }
   void test_parseUnaryExpression_decrement_super_propertyAccess() {
     PrefixExpression expression = ParserTestCase.parse5("parseUnaryExpression", "--super.x", []);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.MINUS_MINUS, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.operand);
-    PropertyAccess operand4 = expression.operand as PropertyAccess;
-    JUnitTestCase.assertTrue(operand4.target is SuperExpression);
-    JUnitTestCase.assertEquals("x", operand4.propertyName.name);
+    PropertyAccess operand2 = expression.operand as PropertyAccess;
+    JUnitTestCase.assertTrue(operand2.target is SuperExpression);
+    JUnitTestCase.assertEquals("x", operand2.propertyName.name);
   }
   void test_parseUnaryExpression_increment_normal() {
     PrefixExpression expression = ParserTestCase.parse5("parseUnaryExpression", "++x", []);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.PLUS_PLUS, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.operand);
   }
   void test_parseUnaryExpression_increment_super_index() {
     PrefixExpression expression = ParserTestCase.parse5("parseUnaryExpression", "++super[0]", []);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.PLUS_PLUS, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.operand);
-    IndexExpression operand5 = expression.operand as IndexExpression;
-    JUnitTestCase.assertTrue(operand5.realTarget is SuperExpression);
-    JUnitTestCase.assertTrue(operand5.index is IntegerLiteral);
+    IndexExpression operand2 = expression.operand as IndexExpression;
+    JUnitTestCase.assertTrue(operand2.realTarget is SuperExpression);
+    JUnitTestCase.assertTrue(operand2.index is IntegerLiteral);
   }
   void test_parseUnaryExpression_increment_super_propertyAccess() {
     PrefixExpression expression = ParserTestCase.parse5("parseUnaryExpression", "++super.x", []);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.PLUS_PLUS, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.operand);
-    PropertyAccess operand6 = expression.operand as PropertyAccess;
-    JUnitTestCase.assertTrue(operand6.target is SuperExpression);
-    JUnitTestCase.assertEquals("x", operand6.propertyName.name);
+    PropertyAccess operand2 = expression.operand as PropertyAccess;
+    JUnitTestCase.assertTrue(operand2.target is SuperExpression);
+    JUnitTestCase.assertEquals("x", operand2.propertyName.name);
   }
   void test_parseUnaryExpression_minus_normal() {
     PrefixExpression expression = ParserTestCase.parse5("parseUnaryExpression", "-x", []);
     JUnitTestCase.assertNotNull(expression.operator);
     JUnitTestCase.assertEquals(TokenType.MINUS, expression.operator.type);
     JUnitTestCase.assertNotNull(expression.operand);
   }
   void test_parseUnaryExpression_minus_super() {
     PrefixExpression expression = ParserTestCase.parse5("parseUnaryExpression", "-super", []);
     JUnitTestCase.assertNotNull(expression.operator);
@@ skipping 2475 matching lines @@
   void test_bitwiseXorExpression_precedence_and_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("x ^ y & z", []);
     EngineTestCase.assertInstanceOf(BinaryExpression, expression.rightOperand);
   }
   void test_bitwiseXorExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super ^ y ^ z", []);
     EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
   }
   void test_cascade_withAssignment() {
     CascadeExpression cascade = ParserTestCase.parseExpression("new Map()..[3] = 4 ..[0] = 11;", []);
-    Expression target4 = cascade.target;
+    Expression target2 = cascade.target;
     for (Expression section in cascade.cascadeSections) {
       EngineTestCase.assertInstanceOf(AssignmentExpression, section);
       Expression lhs = ((section as AssignmentExpression)).leftHandSide;
       EngineTestCase.assertInstanceOf(IndexExpression, lhs);
       IndexExpression index = lhs as IndexExpression;
       JUnitTestCase.assertTrue(index.isCascaded());
-      JUnitTestCase.assertSame(target4, index.realTarget);
+      JUnitTestCase.assertSame(target2, index.realTarget);
     }
   }
   void test_conditionalExpression_precedence_argumentDefinitionTest_not() {
     ConditionalExpression conditional = ParserTestCase.parseExpression("!?a?!?b:!?c", []);
     EngineTestCase.assertInstanceOf(PrefixExpression, conditional.condition);
     EngineTestCase.assertInstanceOf(ArgumentDefinitionTest, ((conditional.condition as PrefixExpression)).operand);
     EngineTestCase.assertInstanceOf(PrefixExpression, conditional.thenExpression);
     EngineTestCase.assertInstanceOf(ArgumentDefinitionTest, ((conditional.thenExpression as PrefixExpression)).operand);
     EngineTestCase.assertInstanceOf(PrefixExpression, conditional.elseExpression);
     EngineTestCase.assertInstanceOf(ArgumentDefinitionTest, ((conditional.elseExpression as PrefixExpression)).operand);
@@ skipping 307 matching lines @@
   }
   Object visitNode(ASTNode node) {
     validate(node);
     return super.visitNode(node);
   }
   /**
    * Validate that the given AST node is correctly constructed.
    * @param node the AST node being validated
    */
   void validate(ASTNode node) {
-    ASTNode parent22 = node.parent;
+    ASTNode parent2 = node.parent;
     if (node is CompilationUnit) {
-      if (parent22 != null) {
+      if (parent2 != null) {
         _errors.add("Compilation units should not have a parent");
       }
     } else {
-      if (parent22 == null) {
+      if (parent2 == null) {
         _errors.add("No parent for ${node.runtimeType.toString()}");
       }
     }
     if (node.beginToken == null) {
       _errors.add("No begin token for ${node.runtimeType.toString()}");
     }
     if (node.endToken == null) {
       _errors.add("No end token for ${node.runtimeType.toString()}");
     }
     int nodeStart = node.offset;
     int nodeLength = node.length;
     if (nodeStart < 0 || nodeLength < 0) {
       _errors.add("No source info for ${node.runtimeType.toString()}");
     }
-    if (parent22 != null) {
+    if (parent2 != null) {
       int nodeEnd = nodeStart + nodeLength;
-      int parentStart = parent22.offset;
-      int parentEnd = parentStart + parent22.length;
+      int parentStart = parent2.offset;
+      int parentEnd = parentStart + parent2.length;
       if (nodeStart < parentStart) {
-        _errors.add("Invalid source start (${nodeStart}) for ${node.runtimeType.toString()} inside ${parent22.runtimeType.toString()} (${parentStart})");
+        _errors.add("Invalid source start (${nodeStart}) for ${node.runtimeType.toString()} inside ${parent2.runtimeType.toString()} (${parentStart})");
       }
       if (nodeEnd > parentEnd) {
-        _errors.add("Invalid source end (${nodeEnd}) for ${node.runtimeType.toString()} inside ${parent22.runtimeType.toString()} (${parentStart})");
+        _errors.add("Invalid source end (${nodeEnd}) for ${node.runtimeType.toString()} inside ${parent2.runtimeType.toString()} (${parentStart})");
       }
     }
   }
 }
 class ParserTestCase extends EngineTestCase {
   /**
    * An empty array of objects used as arguments to zero-argument methods.
    */
   static List<Object> _EMPTY_ARGUMENTS = new List<Object>(0);
   /**
@@ skipping 442 matching lines @@
     List<Expression> result = ParserTestCase.parse5("parseExpressionList", "1, 2, 3,", []);
     EngineTestCase.assertSize(4, result);
     Expression syntheticExpression = result[3];
     EngineTestCase.assertInstanceOf(SimpleIdentifier, syntheticExpression);
     JUnitTestCase.assertTrue(syntheticExpression.isSynthetic());
   }
   void test_isExpression_noType() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("class Bar<T extends Foo> {m(x){if (x is ) return;if (x is !)}}", [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.MISSING_STATEMENT]);
     ClassDeclaration declaration = unit.declarations[0] as ClassDeclaration;
     MethodDeclaration method = declaration.members[0] as MethodDeclaration;
-    BlockFunctionBody body5 = method.body as BlockFunctionBody;
-    IfStatement ifStatement = body5.block.statements[1] as IfStatement;
+    BlockFunctionBody body2 = method.body as BlockFunctionBody;
+    IfStatement ifStatement = body2.block.statements[1] as IfStatement;
     IsExpression expression = ifStatement.condition as IsExpression;
     JUnitTestCase.assertNotNull(expression.expression);
     JUnitTestCase.assertNotNull(expression.isOperator);
     JUnitTestCase.assertNotNull(expression.notOperator);
-    TypeName type37 = expression.type;
-    JUnitTestCase.assertNotNull(type37);
-    JUnitTestCase.assertTrue(type37.name.isSynthetic());
+    TypeName type2 = expression.type;
+    JUnitTestCase.assertNotNull(type2);
+    JUnitTestCase.assertTrue(type2.name.isSynthetic());
     EngineTestCase.assertInstanceOf(EmptyStatement, ifStatement.thenStatement);
   }
   void test_logicalAndExpression_missing_LHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("&& y", []);
     EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic());
   }
   void test_logicalAndExpression_missing_LHS_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("&&", []);
     EngineTestCase.assertInstanceOf(SimpleIdentifier, expression.leftOperand);
@@ skipping 129 matching lines @@
   void test_shiftExpression_precedence_unary_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("<< +", [ParserErrorCode.USE_OF_UNARY_PLUS_OPERATOR]);
     EngineTestCase.assertInstanceOf(BinaryExpression, expression.rightOperand);
   }
   void test_shiftExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super << <<", []);
     EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
   }
   void test_typedef_eof() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("typedef n", [ParserErrorCode.EXPECTED_TOKEN, ParserErrorCode.MISSING_TYPEDEF_PARAMETERS]);
-    NodeList<CompilationUnitMember> declarations3 = unit.declarations;
-    EngineTestCase.assertSize(1, declarations3);
-    CompilationUnitMember member = declarations3[0];
+    NodeList<CompilationUnitMember> declarations2 = unit.declarations;
+    EngineTestCase.assertSize(1, declarations2);
+    CompilationUnitMember member = declarations2[0];
     EngineTestCase.assertInstanceOf(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 1756 matching lines @@
   'validateModifiersForTopLevelFunction_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForTopLevelFunction(arg0)),
   'validateModifiersForTopLevelVariable_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForTopLevelVariable(arg0)),
   'validateModifiersForTypedef_1': new MethodTrampoline(1, (Parser target, arg0) => target.validateModifiersForTypedef(arg0)),};
 
 
 Object invokeParserMethodImpl(Parser parser, String methodName, List<Object> objects, Token tokenStream) {
   parser.currentToken = tokenStream;
   MethodTrampoline method = _methodTable_Parser['${methodName}_${objects.length}'];
   return method.invoke(parser, objects);
 }