Improve java2dart code style - relax 'don't reference variable name in its initializer'.

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;
 import 'ast_test.dart' show ASTFactory;
 /**
  * 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 identifier2 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
-    JUnitTestCase.assertNotNull(identifier2.token);
-    JUnitTestCase.assertEquals("a", identifier2.name);
-    JUnitTestCase.assertEquals(5, identifier2.offset);
+    SimpleIdentifier identifier = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
+    JUnitTestCase.assertNotNull(identifier.token);
+    JUnitTestCase.assertEquals("a", identifier.name);
+    JUnitTestCase.assertEquals(5, identifier.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 215 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 name2 = expression.name;
-    JUnitTestCase.assertNotNull(name2);
-    JUnitTestCase.assertNotNull(name2.label);
-    JUnitTestCase.assertNotNull(name2.colon);
+    Label name = expression.name;
+    JUnitTestCase.assertNotNull(name);
+    JUnitTestCase.assertNotNull(name.label);
+    JUnitTestCase.assertNotNull(name.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> arguments2 = argumentList.arguments;
-    EngineTestCase.assertSize(0, arguments2);
+    NodeList<Expression> arguments = argumentList.arguments;
+    EngineTestCase.assertSize(0, arguments);
   }
   void test_parseArgumentList_mixed() {
     ArgumentList argumentList = ParserTestCase.parse5("parseArgumentList", "(w, x, y: y, z: z)", []);
-    NodeList<Expression> arguments2 = argumentList.arguments;
-    EngineTestCase.assertSize(4, arguments2);
+    NodeList<Expression> arguments = argumentList.arguments;
+    EngineTestCase.assertSize(4, arguments);
   }
   void test_parseArgumentList_noNamed() {
     ArgumentList argumentList = ParserTestCase.parse5("parseArgumentList", "(x, y, z)", []);
-    NodeList<Expression> arguments2 = argumentList.arguments;
-    EngineTestCase.assertSize(3, arguments2);
+    NodeList<Expression> arguments = argumentList.arguments;
+    EngineTestCase.assertSize(3, arguments);
   }
   void test_parseArgumentList_onlyNamed() {
     ArgumentList argumentList = ParserTestCase.parse5("parseArgumentList", "(x: x, y: y)", []);
-    NodeList<Expression> arguments2 = argumentList.arguments;
-    EngineTestCase.assertSize(2, arguments2);
+    NodeList<Expression> arguments = argumentList.arguments;
+    EngineTestCase.assertSize(2, arguments);
   }
   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 argumentList2 = invocation.argumentList;
-    JUnitTestCase.assertNotNull(argumentList2);
-    EngineTestCase.assertSize(1, argumentList2.arguments);
+    ArgumentList argumentList = invocation.argumentList;
+    JUnitTestCase.assertNotNull(argumentList);
+    EngineTestCase.assertSize(1, argumentList.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 argumentList2 = invocation.argumentList;
-    JUnitTestCase.assertNotNull(argumentList2);
-    EngineTestCase.assertSize(1, argumentList2.arguments);
+    ArgumentList argumentList = invocation.argumentList;
+    JUnitTestCase.assertNotNull(argumentList);
+    EngineTestCase.assertSize(1, argumentList.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> variables2 = list.variables;
-    EngineTestCase.assertSize(1, variables2);
-    VariableDeclaration variable = variables2[0];
+    NodeList<VariableDeclaration> variables = list.variables;
+    EngineTestCase.assertSize(1, variables);
+    VariableDeclaration variable = variables[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> variables2 = list.variables;
-    EngineTestCase.assertSize(1, variables2);
-    VariableDeclaration variable = variables2[0];
+    NodeList<VariableDeclaration> variables = list.variables;
+    EngineTestCase.assertSize(1, variables);
+    VariableDeclaration variable = variables[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> variables2 = list.variables;
-    EngineTestCase.assertSize(1, variables2);
-    VariableDeclaration variable = variables2[0];
+    NodeList<VariableDeclaration> variables = list.variables;
+    EngineTestCase.assertSize(1, variables);
+    VariableDeclaration variable = variables[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> variables2 = list.variables;
-    EngineTestCase.assertSize(1, variables2);
-    VariableDeclaration variable = variables2[0];
+    NodeList<VariableDeclaration> variables = list.variables;
+    EngineTestCase.assertSize(1, variables);
+    VariableDeclaration variable = variables[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 token2 = TokenFactory.token(Keyword.TYPEDEF);
-    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token2], "A = B;");
+    Token token = TokenFactory.token(Keyword.TYPEDEF);
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token], "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 token2 = TokenFactory.token(Keyword.TYPEDEF);
-    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token2], "A = abstract B;");
+    Token token = TokenFactory.token(Keyword.TYPEDEF);
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token], "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 token2 = TokenFactory.token(Keyword.TYPEDEF);
-    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token2], "A = B implements C;");
+    Token token = TokenFactory.token(Keyword.TYPEDEF);
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token], "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 token2 = TokenFactory.token(Keyword.TYPEDEF);
-    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token2], "A = B with C;");
+    Token token = TokenFactory.token(Keyword.TYPEDEF);
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token], "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 token2 = TokenFactory.token(Keyword.TYPEDEF);
-    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token2], "A = B with C implements D;");
+    Token token = TokenFactory.token(Keyword.TYPEDEF);
+    ClassTypeAlias classTypeAlias = ParserTestCase.parse("parseClassTypeAlias", <Object> [emptyCommentAndMetadata(), token], "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 74 matching lines @@
     EngineTestCase.assertSize(0, commentAndMetadata.metadata);
   }
   void test_parseCommentAndMetadata_singleLine() {
     CommentAndMetadata commentAndMetadata = ParserTestCase.parse5("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);
-    SimpleIdentifier prefix2 = prefixedIdentifier.prefix;
-    JUnitTestCase.assertNotNull(prefix2.token);
-    JUnitTestCase.assertEquals("a", prefix2.name);
-    JUnitTestCase.assertEquals(11, prefix2.offset);
+    SimpleIdentifier prefix = prefixedIdentifier.prefix;
+    JUnitTestCase.assertNotNull(prefix.token);
+    JUnitTestCase.assertEquals("a", prefix.name);
+    JUnitTestCase.assertEquals(11, prefix.offset);
     JUnitTestCase.assertNotNull(prefixedIdentifier.period);
-    SimpleIdentifier identifier2 = prefixedIdentifier.identifier;
-    JUnitTestCase.assertNotNull(identifier2.token);
-    JUnitTestCase.assertEquals("b", identifier2.name);
-    JUnitTestCase.assertEquals(13, identifier2.offset);
+    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 identifier2 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
-    JUnitTestCase.assertNotNull(identifier2.token);
-    JUnitTestCase.assertEquals("a", identifier2.name);
-    JUnitTestCase.assertEquals(9, identifier2.offset);
+    SimpleIdentifier identifier = EngineTestCase.assertInstanceOf(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);
-    SimpleIdentifier prefix2 = prefixedIdentifier.prefix;
-    JUnitTestCase.assertNotNull(prefix2.token);
-    JUnitTestCase.assertEquals("a", prefix2.name);
-    JUnitTestCase.assertEquals(7, prefix2.offset);
+    SimpleIdentifier prefix = prefixedIdentifier.prefix;
+    JUnitTestCase.assertNotNull(prefix.token);
+    JUnitTestCase.assertEquals("a", prefix.name);
+    JUnitTestCase.assertEquals(7, prefix.offset);
     JUnitTestCase.assertNotNull(prefixedIdentifier.period);
-    SimpleIdentifier identifier2 = prefixedIdentifier.identifier;
-    JUnitTestCase.assertNotNull(identifier2.token);
-    JUnitTestCase.assertEquals("b", identifier2.name);
-    JUnitTestCase.assertEquals(9, identifier2.offset);
+    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 identifier2 = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
-    JUnitTestCase.assertNotNull(identifier2.token);
-    JUnitTestCase.assertEquals("a", identifier2.name);
-    JUnitTestCase.assertEquals(5, identifier2.offset);
+    SimpleIdentifier identifier = EngineTestCase.assertInstanceOf(SimpleIdentifier, reference.identifier);
+    JUnitTestCase.assertNotNull(identifier.token);
+    JUnitTestCase.assertEquals("a", 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], "");
     EngineTestCase.assertSize(2, references);
     CommentReference reference = references[0];
     JUnitTestCase.assertNotNull(reference);
     JUnitTestCase.assertNotNull(reference.identifier);
     JUnitTestCase.assertEquals(12, reference.offset);
     reference = references[1];
@@ skipping 412 matching lines @@
     Comment comment = ParserTestCase.parse5("parseDocumentationComment", "/** */ class", []);
     JUnitTestCase.assertFalse(comment.isBlock());
     JUnitTestCase.assertTrue(comment.isDocumentation());
     JUnitTestCase.assertFalse(comment.isEndOfLine());
   }
   void test_parseDocumentationComment_block_withReference() {
     Comment comment = ParserTestCase.parse5("parseDocumentationComment", "/** [a] */ class", []);
     JUnitTestCase.assertFalse(comment.isBlock());
     JUnitTestCase.assertTrue(comment.isDocumentation());
     JUnitTestCase.assertFalse(comment.isEndOfLine());
-    NodeList<CommentReference> references2 = comment.references;
-    EngineTestCase.assertSize(1, references2);
-    CommentReference reference = references2[0];
+    NodeList<CommentReference> references = comment.references;
+    EngineTestCase.assertSize(1, references);
+    CommentReference reference = references[0];
     JUnitTestCase.assertNotNull(reference);
     JUnitTestCase.assertEquals(5, reference.offset);
   }
   void test_parseDocumentationComment_endOfLine() {
     Comment comment = ParserTestCase.parse5("parseDocumentationComment", "/// \n/// \n class", []);
     JUnitTestCase.assertFalse(comment.isBlock());
     JUnitTestCase.assertTrue(comment.isDocumentation());
     JUnitTestCase.assertFalse(comment.isEndOfLine());
   }
   void test_parseDoStatement() {
@@ skipping 118 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 keyword2 = result.keyword;
-    JUnitTestCase.assertNotNull(keyword2);
-    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword2.type);
-    JUnitTestCase.assertEquals(Keyword.CONST, ((keyword2 as KeywordToken)).keyword);
+    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);
   }
   void test_parseFinalConstVarOrType_const_type() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "const A a");
-    Token keyword2 = result.keyword;
-    JUnitTestCase.assertNotNull(keyword2);
-    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword2.type);
-    JUnitTestCase.assertEquals(Keyword.CONST, ((keyword2 as KeywordToken)).keyword);
+    Token keyword = result.keyword;
+    JUnitTestCase.assertNotNull(keyword);
+    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword.type);
+    JUnitTestCase.assertEquals(Keyword.CONST, ((keyword as KeywordToken)).keyword);
     JUnitTestCase.assertNotNull(result.type);
   }
   void test_parseFinalConstVarOrType_final_noType() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "final");
-    Token keyword2 = result.keyword;
-    JUnitTestCase.assertNotNull(keyword2);
-    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword2.type);
-    JUnitTestCase.assertEquals(Keyword.FINAL, ((keyword2 as KeywordToken)).keyword);
+    Token keyword = result.keyword;
+    JUnitTestCase.assertNotNull(keyword);
+    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword.type);
+    JUnitTestCase.assertEquals(Keyword.FINAL, ((keyword as KeywordToken)).keyword);
     JUnitTestCase.assertNull(result.type);
   }
   void test_parseFinalConstVarOrType_final_prefixedType() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "final p.A a");
-    Token keyword2 = result.keyword;
-    JUnitTestCase.assertNotNull(keyword2);
-    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword2.type);
-    JUnitTestCase.assertEquals(Keyword.FINAL, ((keyword2 as KeywordToken)).keyword);
+    Token keyword = result.keyword;
+    JUnitTestCase.assertNotNull(keyword);
+    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword.type);
+    JUnitTestCase.assertEquals(Keyword.FINAL, ((keyword as KeywordToken)).keyword);
     JUnitTestCase.assertNotNull(result.type);
   }
   void test_parseFinalConstVarOrType_final_type() {
     FinalConstVarOrType result = ParserTestCase.parse("parseFinalConstVarOrType", <Object> [false], "final A a");
-    Token keyword2 = result.keyword;
-    JUnitTestCase.assertNotNull(keyword2);
-    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword2.type);
-    JUnitTestCase.assertEquals(Keyword.FINAL, ((keyword2 as KeywordToken)).keyword);
+    Token keyword = result.keyword;
+    JUnitTestCase.assertNotNull(keyword);
+    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword.type);
+    JUnitTestCase.assertEquals(Keyword.FINAL, ((keyword 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 keyword2 = result.keyword;
-    JUnitTestCase.assertNotNull(keyword2);
-    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword2.type);
-    JUnitTestCase.assertEquals(Keyword.VAR, ((keyword2 as KeywordToken)).keyword);
+    Token keyword = result.keyword;
+    JUnitTestCase.assertNotNull(keyword);
+    JUnitTestCase.assertEquals(TokenType.KEYWORD, keyword.type);
+    JUnitTestCase.assertEquals(Keyword.VAR, ((keyword 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 variables2 = statement.variables;
-    JUnitTestCase.assertNotNull(variables2);
-    EngineTestCase.assertSize(0, variables2.metadata);
-    EngineTestCase.assertSize(1, variables2.variables);
+    VariableDeclarationList variables = statement.variables;
+    JUnitTestCase.assertNotNull(variables);
+    EngineTestCase.assertSize(0, variables.metadata);
+    EngineTestCase.assertSize(1, variables.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 variables2 = statement.variables;
-    JUnitTestCase.assertNotNull(variables2);
-    EngineTestCase.assertSize(1, variables2.metadata);
-    EngineTestCase.assertSize(1, variables2.variables);
+    VariableDeclarationList variables = statement.variables;
+    JUnitTestCase.assertNotNull(variables);
+    EngineTestCase.assertSize(1, variables.metadata);
+    EngineTestCase.assertSize(1, variables.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 variables2 = statement.variables;
-    JUnitTestCase.assertNotNull(variables2);
-    EngineTestCase.assertSize(1, variables2.variables);
+    VariableDeclarationList variables = statement.variables;
+    JUnitTestCase.assertNotNull(variables);
+    EngineTestCase.assertSize(1, variables.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 variables2 = statement.variables;
-    JUnitTestCase.assertNotNull(variables2);
-    EngineTestCase.assertSize(1, variables2.variables);
+    VariableDeclarationList variables = statement.variables;
+    JUnitTestCase.assertNotNull(variables);
+    EngineTestCase.assertSize(1, variables.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 variables2 = statement.variables;
-    JUnitTestCase.assertNotNull(variables2);
-    EngineTestCase.assertSize(2, variables2.variables);
+    VariableDeclarationList variables = statement.variables;
+    JUnitTestCase.assertNotNull(variables);
+    EngineTestCase.assertSize(2, variables.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 variables2 = statement.variables;
-    JUnitTestCase.assertNotNull(variables2);
-    EngineTestCase.assertSize(1, variables2.variables);
+    VariableDeclarationList variables = statement.variables;
+    JUnitTestCase.assertNotNull(variables);
+    EngineTestCase.assertSize(1, variables.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 fields2 = declaration.fields;
-    JUnitTestCase.assertNotNull(fields2);
-    JUnitTestCase.assertNull(fields2.keyword);
-    JUnitTestCase.assertEquals(type, fields2.type);
-    EngineTestCase.assertSize(3, fields2.variables);
+    VariableDeclarationList fields = declaration.fields;
+    JUnitTestCase.assertNotNull(fields);
+    JUnitTestCase.assertNull(fields.keyword);
+    JUnitTestCase.assertEquals(type, fields.type);
+    EngineTestCase.assertSize(3, fields.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 fields2 = declaration.fields;
-    JUnitTestCase.assertNotNull(fields2);
-    JUnitTestCase.assertEquals(varKeyword, fields2.keyword);
-    JUnitTestCase.assertNull(fields2.type);
-    EngineTestCase.assertSize(3, fields2.variables);
+    VariableDeclarationList fields = declaration.fields;
+    JUnitTestCase.assertNotNull(fields);
+    JUnitTestCase.assertEquals(varKeyword, fields.keyword);
+    JUnitTestCase.assertNull(fields.type);
+    EngineTestCase.assertSize(3, fields.variables);
     JUnitTestCase.assertEquals(staticKeyword, declaration.keyword);
     JUnitTestCase.assertNotNull(declaration.semicolon);
   }
   void test_parseInstanceCreationExpression_qualifiedType() {
-    Token token2 = TokenFactory.token(Keyword.NEW);
-    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token2], "A.B()");
-    JUnitTestCase.assertEquals(token2, expression.keyword);
+    Token token = TokenFactory.token(Keyword.NEW);
+    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token], "A.B()");
+    JUnitTestCase.assertEquals(token, 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 token2 = TokenFactory.token(Keyword.NEW);
-    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token2], "A.B.c()");
-    JUnitTestCase.assertEquals(token2, expression.keyword);
+    Token token = TokenFactory.token(Keyword.NEW);
+    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token], "A.B.c()");
+    JUnitTestCase.assertEquals(token, 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 token2 = TokenFactory.token(Keyword.NEW);
-    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token2], "A()");
-    JUnitTestCase.assertEquals(token2, expression.keyword);
+    Token token = TokenFactory.token(Keyword.NEW);
+    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token], "A()");
+    JUnitTestCase.assertEquals(token, 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 token2 = TokenFactory.token(Keyword.NEW);
-    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token2], "A<B>.c()");
-    JUnitTestCase.assertEquals(token2, expression.keyword);
+    Token token = TokenFactory.token(Keyword.NEW);
+    InstanceCreationExpression expression = ParserTestCase.parse("parseInstanceCreationExpression", <Object> [token], "A<B>.c()");
+    JUnitTestCase.assertEquals(token, 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 token2 = TokenFactory.token(Keyword.CONST);
+    Token token = TokenFactory.token(Keyword.CONST);
     TypeArgumentList typeArguments = new TypeArgumentList.full(null, null, null);
-    ListLiteral literal = ParserTestCase.parse("parseListLiteral", <Object> [token2, typeArguments], "[]");
-    JUnitTestCase.assertEquals(token2, literal.modifier);
+    ListLiteral literal = ParserTestCase.parse("parseListLiteral", <Object> [token, typeArguments], "[]");
+    JUnitTestCase.assertEquals(token, 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 token2 = TokenFactory.token(Keyword.CONST);
+    Token token = TokenFactory.token(Keyword.CONST);
     TypeArgumentList typeArguments = new TypeArgumentList.full(null, null, null);
-    ListLiteral literal = ParserTestCase.parse("parseListLiteral", <Object> [token2, typeArguments], "[ ]");
-    JUnitTestCase.assertEquals(token2, literal.modifier);
+    ListLiteral literal = ParserTestCase.parse("parseListLiteral", <Object> [token, typeArguments], "[ ]");
+    JUnitTestCase.assertEquals(token, 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 token2 = TokenFactory.token(Keyword.CONST);
+    Token token = TokenFactory.token(Keyword.CONST);
     TypeArgumentList typeArguments = ASTFactory.typeArgumentList([ASTFactory.typeName4("String", []), ASTFactory.typeName4("int", [])]);
-    MapLiteral literal = ParserTestCase.parse("parseMapLiteral", <Object> [token2, typeArguments], "{}");
-    JUnitTestCase.assertEquals(token2, literal.modifier);
+    MapLiteral literal = ParserTestCase.parse("parseMapLiteral", <Object> [token, typeArguments], "{}");
+    JUnitTestCase.assertEquals(token, 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 563 matching lines @@
   void test_parseStatements_multiple() {
     List<Statement> statements = ParserTestCase.parseStatements("return; return;", 2, []);
     EngineTestCase.assertSize(2, statements);
   }
   void test_parseStatements_single() {
     List<Statement> statements = ParserTestCase.parseStatements("return;", 1, []);
     EngineTestCase.assertSize(1, statements);
   }
   void test_parseStringLiteral_adjacent() {
     AdjacentStrings literal = ParserTestCase.parse5("parseStringLiteral", "'a' 'b'", []);
-    NodeList<StringLiteral> strings2 = literal.strings;
-    EngineTestCase.assertSize(2, strings2);
-    StringLiteral firstString = strings2[0];
-    StringLiteral secondString = strings2[1];
+    NodeList<StringLiteral> strings = literal.strings;
+    EngineTestCase.assertSize(2, strings);
+    StringLiteral firstString = strings[0];
+    StringLiteral secondString = strings[1];
     JUnitTestCase.assertEquals("a", ((firstString as SimpleStringLiteral)).value);
     JUnitTestCase.assertEquals("b", ((secondString as SimpleStringLiteral)).value);
   }
   void test_parseStringLiteral_interpolated() {
     StringInterpolation literal = ParserTestCase.parse5("parseStringLiteral", "'a \${b} c \$this d'", []);
-    NodeList<InterpolationElement> elements2 = literal.elements;
-    EngineTestCase.assertSize(5, elements2);
-    JUnitTestCase.assertTrue(elements2[0] is InterpolationString);
-    JUnitTestCase.assertTrue(elements2[1] is InterpolationExpression);
-    JUnitTestCase.assertTrue(elements2[2] is InterpolationString);
-    JUnitTestCase.assertTrue(elements2[3] is InterpolationExpression);
-    JUnitTestCase.assertTrue(elements2[4] is InterpolationString);
+    NodeList<InterpolationElement> elements = literal.elements;
+    EngineTestCase.assertSize(5, elements);
+    JUnitTestCase.assertTrue(elements[0] is InterpolationString);
+    JUnitTestCase.assertTrue(elements[1] is InterpolationExpression);
+    JUnitTestCase.assertTrue(elements[2] is InterpolationString);
+    JUnitTestCase.assertTrue(elements[3] is InterpolationExpression);
+    JUnitTestCase.assertTrue(elements[4] is InterpolationString);
   }
   void test_parseStringLiteral_single() {
     SimpleStringLiteral literal = ParserTestCase.parse5("parseStringLiteral", "'a'", []);
     JUnitTestCase.assertNotNull(literal.literal);
     JUnitTestCase.assertEquals("a", literal.value);
   }
   void test_parseSuperConstructorInvocation_named() {
     SuperConstructorInvocation invocation = ParserTestCase.parse5("parseSuperConstructorInvocation", "super.a()", []);
     JUnitTestCase.assertNotNull(invocation.argumentList);
     JUnitTestCase.assertNotNull(invocation.constructorName);
@@ skipping 56 matching lines @@
   }
   void test_parseThrowExpressionWithoutCascade() {
     ThrowExpression expression = ParserTestCase.parse5("parseThrowExpressionWithoutCascade", "throw x;", []);
     JUnitTestCase.assertNotNull(expression.keyword);
     JUnitTestCase.assertNotNull(expression.expression);
   }
   void test_parseTryStatement_catch() {
     TryStatement statement = ParserTestCase.parse5("parseTryStatement", "try {} catch (e) {}", []);
     JUnitTestCase.assertNotNull(statement.tryKeyword);
     JUnitTestCase.assertNotNull(statement.body);
-    NodeList<CatchClause> catchClauses2 = statement.catchClauses;
-    EngineTestCase.assertSize(1, catchClauses2);
-    CatchClause clause = catchClauses2[0];
+    NodeList<CatchClause> catchClauses = statement.catchClauses;
+    EngineTestCase.assertSize(1, catchClauses);
+    CatchClause clause = catchClauses[0];
     JUnitTestCase.assertNull(clause.onKeyword);
     JUnitTestCase.assertNull(clause.exceptionType);
     JUnitTestCase.assertNotNull(clause.catchKeyword);
     JUnitTestCase.assertNotNull(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_catch_finally() {
     TryStatement statement = ParserTestCase.parse5("parseTryStatement", "try {} catch (e, s) {} finally {}", []);
     JUnitTestCase.assertNotNull(statement.tryKeyword);
     JUnitTestCase.assertNotNull(statement.body);
-    NodeList<CatchClause> catchClauses2 = statement.catchClauses;
-    EngineTestCase.assertSize(1, catchClauses2);
-    CatchClause clause = catchClauses2[0];
+    NodeList<CatchClause> catchClauses = statement.catchClauses;
+    EngineTestCase.assertSize(1, catchClauses);
+    CatchClause clause = catchClauses[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> catchClauses2 = statement.catchClauses;
-    EngineTestCase.assertSize(1, catchClauses2);
-    CatchClause clause = catchClauses2[0];
+    NodeList<CatchClause> catchClauses = statement.catchClauses;
+    EngineTestCase.assertSize(1, catchClauses);
+    CatchClause clause = catchClauses[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> catchClauses2 = statement.catchClauses;
-    EngineTestCase.assertSize(1, catchClauses2);
-    CatchClause clause = catchClauses2[0];
+    NodeList<CatchClause> catchClauses = statement.catchClauses;
+    EngineTestCase.assertSize(1, catchClauses);
+    CatchClause clause = catchClauses[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> catchClauses2 = statement.catchClauses;
-    EngineTestCase.assertSize(1, catchClauses2);
-    CatchClause clause = catchClauses2[0];
+    NodeList<CatchClause> catchClauses = statement.catchClauses;
+    EngineTestCase.assertSize(1, catchClauses);
+    CatchClause clause = catchClauses[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 operand2 = expression.operand as PropertyAccess;
-    JUnitTestCase.assertTrue(operand2.target is SuperExpression);
-    JUnitTestCase.assertEquals("x", operand2.propertyName.name);
+    PropertyAccess operand = expression.operand as PropertyAccess;
+    JUnitTestCase.assertTrue(operand.target is SuperExpression);
+    JUnitTestCase.assertEquals("x", operand.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 operand2 = expression.operand as IndexExpression;
-    JUnitTestCase.assertTrue(operand2.realTarget is SuperExpression);
-    JUnitTestCase.assertTrue(operand2.index is IntegerLiteral);
+    IndexExpression operand = expression.operand as IndexExpression;
+    JUnitTestCase.assertTrue(operand.realTarget is SuperExpression);
+    JUnitTestCase.assertTrue(operand.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 operand2 = expression.operand as PropertyAccess;
-    JUnitTestCase.assertTrue(operand2.target is SuperExpression);
-    JUnitTestCase.assertEquals("x", operand2.propertyName.name);
+    PropertyAccess operand = expression.operand as PropertyAccess;
+    JUnitTestCase.assertTrue(operand.target is SuperExpression);
+    JUnitTestCase.assertEquals("x", operand.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 2519 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 target2 = cascade.target;
+    Expression target = 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(target2, index.realTarget);
+      JUnitTestCase.assertSame(target, index.realTarget);
     }
   }
   void test_conditionalExpression_precedence_logicalOrExpression() {
     ConditionalExpression expression = ParserTestCase.parseExpression("a | b ? y : z", []);
     EngineTestCase.assertInstanceOf(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> declarations2 = unit.declarations;
-    EngineTestCase.assertSize(1, declarations2);
+    NodeList<CompilationUnitMember> declarations = unit.declarations;
+    EngineTestCase.assertSize(1, declarations);
   }
   void test_equalityExpression_normal() {
     BinaryExpression expression = ParserTestCase.parseExpression("x == y != z", []);
     EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
   }
   void test_equalityExpression_precedence_relational_left() {
     BinaryExpression expression = ParserTestCase.parseExpression("x is y == z", []);
     EngineTestCase.assertInstanceOf(IsExpression, expression.leftOperand);
   }
   void test_equalityExpression_precedence_relational_right() {
@@ skipping 287 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 parent2 = node.parent;
+    ASTNode parent = node.parent;
     if (node is CompilationUnit) {
-      if (parent2 != null) {
+      if (parent != null) {
         _errors.add("Compilation units should not have a parent");
       }
     } else {
-      if (parent2 == null) {
+      if (parent == 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 (parent2 != null) {
+    if (parent != null) {
       int nodeEnd = nodeStart + nodeLength;
-      int parentStart = parent2.offset;
-      int parentEnd = parentStart + parent2.length;
+      int parentStart = parent.offset;
+      int parentEnd = parentStart + parent.length;
       if (nodeStart < parentStart) {
-        _errors.add("Invalid source start (${nodeStart}) for ${node.runtimeType.toString()} inside ${parent2.runtimeType.toString()} (${parentStart})");
+        _errors.add("Invalid source start (${nodeStart}) for ${node.runtimeType.toString()} inside ${parent.runtimeType.toString()} (${parentStart})");
       }
       if (nodeEnd > parentEnd) {
-        _errors.add("Invalid source end (${nodeEnd}) for ${node.runtimeType.toString()} inside ${parent2.runtimeType.toString()} (${parentStart})");
+        _errors.add("Invalid source end (${nodeEnd}) for ${node.runtimeType.toString()} inside ${parent.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 457 matching lines @@
     List<Expression> result = ParserTestCase.parse5("parseExpressionList", "1, 2, 3,", [ParserErrorCode.MISSING_IDENTIFIER]);
     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.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 body2 = method.body as BlockFunctionBody;
-    IfStatement ifStatement = body2.block.statements[1] as IfStatement;
+    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 type2 = expression.type;
-    JUnitTestCase.assertNotNull(type2);
-    JUnitTestCase.assertTrue(type2.name.isSynthetic());
+    TypeName type = expression.type;
+    JUnitTestCase.assertNotNull(type);
+    JUnitTestCase.assertTrue(type.name.isSynthetic());
     EngineTestCase.assertInstanceOf(EmptyStatement, ifStatement.thenStatement);
   }
   void test_logicalAndExpression_missing_LHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("&& y", [ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf(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);
@@ skipping 129 matching lines @@
   void test_shiftExpression_precedence_unary_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("<< +", [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf(BinaryExpression, expression.rightOperand);
   }
   void test_shiftExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super << <<", [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf(BinaryExpression, expression.leftOperand);
   }
   void test_typedef_eof() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit("typedef n", [ParserErrorCode.EXPECTED_TOKEN, ParserErrorCode.MISSING_TYPEDEF_PARAMETERS]);
-    NodeList<CompilationUnitMember> declarations2 = unit.declarations;
-    EngineTestCase.assertSize(1, declarations2);
-    CompilationUnitMember member = declarations2[0];
+    NodeList<CompilationUnitMember> declarations = unit.declarations;
+    EngineTestCase.assertSize(1, declarations);
+    CompilationUnitMember member = declarations[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 1872 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);
 }