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

pkg/analyzer_experimental/test/generated/resolver_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.resolver_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_io.dart';
 import 'package:analyzer_experimental/src/generated/error.dart';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
@@ skipping 12 matching lines @@
 class TypePropagationTest extends ResolverTestCase {
   void test_as() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  bool get g => true;", "}", "A f(var p) {", "  if ((p as A).g) {", "    return p;", "  } else {", "    return null;", "  }", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    IfStatement ifStatement = body2.block.statements[0] as IfStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = ((ifStatement.thenStatement as Block)).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_assert() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "A f(var p) {", "  assert (p is A);", "  return p;", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    ReturnStatement statement = body2.block.statements[1] as ReturnStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_assignment() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var v;", "  v = 0;", "  return v;", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    ReturnStatement statement = body2.block.statements[2] as ReturnStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    ReturnStatement statement = body.block.statements[2] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeProvider.intType, variableName.propagatedType);
   }
   void test_assignment_afterInitializer() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var v = 0;", "  v = 1.0;", "  return v;", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    ReturnStatement statement = body2.block.statements[2] as ReturnStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    ReturnStatement statement = body.block.statements[2] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeProvider.doubleType, variableName.propagatedType);
   }
   void test_forEach() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "A f(List<A> p) {", "  for (var e in p) {", "    return e;", "  }", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    ForEachStatement forStatement = body2.block.statements[0] as ForEachStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    ForEachStatement forStatement = body.block.statements[0] as ForEachStatement;
     ReturnStatement statement = ((forStatement.body as Block)).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_initializer() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var v = 0;", "  return v;", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    ReturnStatement statement = body2.block.statements[1] as ReturnStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeProvider.intType, variableName.propagatedType);
   }
   void test_initializer_dereference() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var v = 'String';", "  v.", "}"]));
     LibraryElement library = resolve(source);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    ExpressionStatement statement = body2.block.statements[1] as ExpressionStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    ExpressionStatement statement = body.block.statements[1] as ExpressionStatement;
     PrefixedIdentifier invocation = statement.expression as PrefixedIdentifier;
     SimpleIdentifier variableName = invocation.prefix;
     JUnitTestCase.assertSame(typeProvider.stringType, variableName.propagatedType);
   }
   void test_is_conditional() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "A f(var p) {", "  return (p is A) ? p : null;", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    ReturnStatement statement = body2.block.statements[0] as ReturnStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    ReturnStatement statement = body.block.statements[0] as ReturnStatement;
     ConditionalExpression conditional = statement.expression as ConditionalExpression;
     SimpleIdentifier variableName = conditional.thenExpression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_is_if() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "A f(var p) {", "  if (p is A) {", "    return p;", "  } else {", "    return null;", "  }", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    IfStatement ifStatement = body2.block.statements[0] as IfStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = ((ifStatement.thenStatement as Block)).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_is_if_lessSpecific() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "A f(A p) {", "  if (p is Object) {", "    return p;", "  } else {", "    return null;", "  }", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    IfStatement ifStatement = body2.block.statements[0] as IfStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = ((ifStatement.thenStatement as Block)).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(null, variableName.propagatedType);
   }
   void test_is_if_logicalAnd() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "A f(var p) {", "  if (p is A && p != null) {", "    return p;", "  } else {", "    return null;", "  }", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    IfStatement ifStatement = body2.block.statements[0] as IfStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = ((ifStatement.thenStatement as Block)).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_is_postConditional() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "A f(var p) {", "  A a = (p is A) ? p : throw null;", "  return p;", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    ReturnStatement statement = body2.block.statements[1] as ReturnStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_is_postIf() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "A f(var p) {", "  if (p is A) {", "    A a = p;", "  } else {", "    return null;", "  }", "  return p;", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    ReturnStatement statement = body2.block.statements[1] as ReturnStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_is_subclass() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "class B extends A {", "  B m() => this;", "}", "A f(A p) {", "  if (p is B) {", "    return p.m();", "  }", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[2] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    IfStatement ifStatement = body2.block.statements[0] as IfStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = ((ifStatement.thenStatement as Block)).statements[0] as ReturnStatement;
     MethodInvocation invocation = statement.expression as MethodInvocation;
     JUnitTestCase.assertNotNull(invocation.methodName.element);
   }
   void test_is_while() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "A f(var p) {", "  while (p is A) {", "    return p;", "  }", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    WhileStatement whileStatement = body2.block.statements[0] as WhileStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    WhileStatement whileStatement = body.block.statements[0] as WhileStatement;
     ReturnStatement statement = ((whileStatement.body as Block)).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_isNot_conditional() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "A f(var p) {", "  return (p is! A) ? null : p;", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    ReturnStatement statement = body2.block.statements[0] as ReturnStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    ReturnStatement statement = body.block.statements[0] as ReturnStatement;
     ConditionalExpression conditional = statement.expression as ConditionalExpression;
     SimpleIdentifier variableName = conditional.elseExpression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_isNot_if() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "A f(var p) {", "  if (p is! A) {", "    return null;", "  } else {", "    return p;", "  }", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    IfStatement ifStatement = body2.block.statements[0] as IfStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = ((ifStatement.elseStatement as Block)).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_isNot_if_logicalOr() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "A f(var p) {", "  if (p is! A || null == p) {", "    return null;", "  } else {", "    return p;", "  }", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    IfStatement ifStatement = body2.block.statements[0] as IfStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = ((ifStatement.elseStatement as Block)).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_isNot_postConditional() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "A f(var p) {", "  A a = (p is! A) ? throw null : p;", "  return p;", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    ReturnStatement statement = body2.block.statements[1] as ReturnStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_isNot_postIf() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "A f(var p) {", "  if (p is! A) {", "    return null;", "  }", "  return p;", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    ReturnStatement statement = body2.block.statements[1] as ReturnStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
   void test_listLiteral_different() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var v = [0, '1', 2];", "  return v[2];", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    ReturnStatement statement = body2.block.statements[1] as ReturnStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     IndexExpression indexExpression = statement.expression as IndexExpression;
     JUnitTestCase.assertNull(indexExpression.propagatedType);
   }
   void test_listLiteral_same() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var v = [0, 1, 2];", "  return v[2];", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    ReturnStatement statement = body2.block.statements[1] as ReturnStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     IndexExpression indexExpression = statement.expression as IndexExpression;
     JUnitTestCase.assertSame(typeProvider.intType, indexExpression.propagatedType);
   }
   void test_mapLiteral_different() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var v = {'0' : 0, 1 : '1', '2' : 2};", "  return v;", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    ReturnStatement statement = body2.block.statements[1] as ReturnStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier identifier = statement.expression as SimpleIdentifier;
-    InterfaceType propagatedType2 = identifier.propagatedType as InterfaceType;
-    JUnitTestCase.assertSame(typeProvider.mapType.element, propagatedType2.element);
-    List<Type2> typeArguments2 = propagatedType2.typeArguments;
-    EngineTestCase.assertLength(2, typeArguments2);
-    JUnitTestCase.assertSame(typeProvider.dynamicType, typeArguments2[0]);
-    JUnitTestCase.assertSame(typeProvider.dynamicType, typeArguments2[1]);
+    InterfaceType propagatedType = identifier.propagatedType as InterfaceType;
+    JUnitTestCase.assertSame(typeProvider.mapType.element, propagatedType.element);
+    List<Type2> typeArguments = propagatedType.typeArguments;
+    EngineTestCase.assertLength(2, typeArguments);
+    JUnitTestCase.assertSame(typeProvider.dynamicType, typeArguments[0]);
+    JUnitTestCase.assertSame(typeProvider.dynamicType, typeArguments[1]);
   }
   void test_mapLiteral_same() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var v = {'a' : 0, 'b' : 1, 'c' : 2};", "  return v;", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
-    BlockFunctionBody body2 = function.functionExpression.body as BlockFunctionBody;
-    ReturnStatement statement = body2.block.statements[1] as ReturnStatement;
+    BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
+    ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier identifier = statement.expression as SimpleIdentifier;
-    InterfaceType propagatedType2 = identifier.propagatedType as InterfaceType;
-    JUnitTestCase.assertSame(typeProvider.mapType.element, propagatedType2.element);
-    List<Type2> typeArguments2 = propagatedType2.typeArguments;
-    EngineTestCase.assertLength(2, typeArguments2);
-    JUnitTestCase.assertSame(typeProvider.stringType, typeArguments2[0]);
-    JUnitTestCase.assertSame(typeProvider.intType, typeArguments2[1]);
+    InterfaceType propagatedType = identifier.propagatedType as InterfaceType;
+    JUnitTestCase.assertSame(typeProvider.mapType.element, propagatedType.element);
+    List<Type2> typeArguments = propagatedType.typeArguments;
+    EngineTestCase.assertLength(2, typeArguments);
+    JUnitTestCase.assertSame(typeProvider.stringType, typeArguments[0]);
+    JUnitTestCase.assertSame(typeProvider.intType, typeArguments[1]);
   }
   void test_query() {
     Source source = addSource(EngineTestCase.createSource(["import 'dart:html';", "", "main() {", "  var v1 = query('a');", "  var v2 = query('A');", "  var v3 = query('body:active');", "  var v4 = query('button[foo=\"bar\"]');", "  var v5 = query('div.class');", "  var v6 = query('input#id');", "  var v7 = query('select#id');", "  // invocation of method", "  var m1 = document.query('div');", " // unsupported currently", "  var b1 = query('noSuchTag');", "  var b2 = query('DART_EDITOR_NO_SUCH_TYPE');", "  var b3 = query('body div');", "  return [v1, v2, v3, v4, v5, v6, v7, m1, b1, b2, b3];", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration main = unit.declarations[0] as FunctionDeclaration;
-    BlockFunctionBody body2 = main.functionExpression.body as BlockFunctionBody;
-    ReturnStatement statement = body2.block.statements[11] as ReturnStatement;
-    NodeList<Expression> elements2 = ((statement.expression as ListLiteral)).elements;
-    JUnitTestCase.assertEquals("AnchorElement", elements2[0].propagatedType.name);
-    JUnitTestCase.assertEquals("AnchorElement", elements2[1].propagatedType.name);
-    JUnitTestCase.assertEquals("BodyElement", elements2[2].propagatedType.name);
-    JUnitTestCase.assertEquals("ButtonElement", elements2[3].propagatedType.name);
-    JUnitTestCase.assertEquals("DivElement", elements2[4].propagatedType.name);
-    JUnitTestCase.assertEquals("InputElement", elements2[5].propagatedType.name);
-    JUnitTestCase.assertEquals("SelectElement", elements2[6].propagatedType.name);
-    JUnitTestCase.assertEquals("DivElement", elements2[7].propagatedType.name);
-    JUnitTestCase.assertEquals("Element", elements2[8].propagatedType.name);
-    JUnitTestCase.assertEquals("Element", elements2[9].propagatedType.name);
-    JUnitTestCase.assertEquals("Element", elements2[10].propagatedType.name);
+    BlockFunctionBody body = main.functionExpression.body as BlockFunctionBody;
+    ReturnStatement statement = body.block.statements[11] as ReturnStatement;
+    NodeList<Expression> elements = ((statement.expression as ListLiteral)).elements;
+    JUnitTestCase.assertEquals("AnchorElement", elements[0].propagatedType.name);
+    JUnitTestCase.assertEquals("AnchorElement", elements[1].propagatedType.name);
+    JUnitTestCase.assertEquals("BodyElement", elements[2].propagatedType.name);
+    JUnitTestCase.assertEquals("ButtonElement", elements[3].propagatedType.name);
+    JUnitTestCase.assertEquals("DivElement", elements[4].propagatedType.name);
+    JUnitTestCase.assertEquals("InputElement", elements[5].propagatedType.name);
+    JUnitTestCase.assertEquals("SelectElement", elements[6].propagatedType.name);
+    JUnitTestCase.assertEquals("DivElement", elements[7].propagatedType.name);
+    JUnitTestCase.assertEquals("Element", elements[8].propagatedType.name);
+    JUnitTestCase.assertEquals("Element", elements[9].propagatedType.name);
+    JUnitTestCase.assertEquals("Element", elements[10].propagatedType.name);
   }
   static dartSuite() {
     _ut.group('TypePropagationTest', () {
       _ut.test('test_as', () {
         final __test = new TypePropagationTest();
         runJUnitTest(__test, __test.test_as);
       });
       _ut.test('test_assert', () {
         final __test = new TypePropagationTest();
         runJUnitTest(__test, __test.test_assert);
@@ skipping 1901 matching lines @@
   void setUp() {
     _sourceFactory = new SourceFactory.con2([new FileUriResolver()]);
     _analysisContext = new AnalysisContextImpl();
     _analysisContext.sourceFactory = _sourceFactory;
     _errorListener = new GatheringErrorListener();
     _library5 = library("/lib.dart");
   }
   void test_addExport() {
     Library exportLibrary = library("/exported.dart");
     _library5.addExport(ASTFactory.exportDirective2("exported.dart", []), exportLibrary);
-    List<Library> exports2 = _library5.exports;
-    EngineTestCase.assertLength(1, exports2);
-    JUnitTestCase.assertSame(exportLibrary, exports2[0]);
+    List<Library> exports = _library5.exports;
+    EngineTestCase.assertLength(1, exports);
+    JUnitTestCase.assertSame(exportLibrary, exports[0]);
     _errorListener.assertNoErrors();
   }
   void test_addImport() {
     Library importLibrary = library("/imported.dart");
     _library5.addImport(ASTFactory.importDirective2("imported.dart", null, []), importLibrary);
-    List<Library> imports2 = _library5.imports;
-    EngineTestCase.assertLength(1, imports2);
-    JUnitTestCase.assertSame(importLibrary, imports2[0]);
+    List<Library> imports = _library5.imports;
+    EngineTestCase.assertLength(1, imports);
+    JUnitTestCase.assertSame(importLibrary, imports[0]);
     _errorListener.assertNoErrors();
   }
   void test_getExplicitlyImportsCore() {
     JUnitTestCase.assertFalse(_library5.explicitlyImportsCore);
     _errorListener.assertNoErrors();
   }
   void test_getExport() {
     ExportDirective directive = ASTFactory.exportDirective2("exported.dart", []);
     Library exportLibrary = library("/exported.dart");
     _library5.addExport(directive, exportLibrary);
@@ skipping 549 matching lines @@
     Source librarySource = new FileBasedSource.con1(factory.contentCache, FileUtilities2.createFile("/lib.dart"));
     _library = new Library(context, _listener, librarySource);
     LibraryElementImpl element = new LibraryElementImpl(context, ASTFactory.libraryIdentifier2(["lib"]));
     element.definingCompilationUnit = new CompilationUnitElementImpl("lib.dart");
     _library.libraryElement = element;
     _typeProvider = new TestTypeProvider();
     _visitor = new TypeResolverVisitor.con1(_library, librarySource, _typeProvider);
   }
   void test_visitCatchClause_exception() {
     CatchClause clause = ASTFactory.catchClause("e", []);
-    SimpleIdentifier exceptionParameter2 = clause.exceptionParameter;
-    exceptionParameter2.element = new LocalVariableElementImpl(exceptionParameter2);
+    SimpleIdentifier exceptionParameter = clause.exceptionParameter;
+    exceptionParameter.element = new LocalVariableElementImpl(exceptionParameter);
     resolve(clause, _typeProvider.objectType, null, []);
     _listener.assertNoErrors();
   }
   void test_visitCatchClause_exception_stackTrace() {
     CatchClause clause = ASTFactory.catchClause2("e", "s", []);
-    SimpleIdentifier exceptionParameter2 = clause.exceptionParameter;
-    exceptionParameter2.element = new LocalVariableElementImpl(exceptionParameter2);
-    SimpleIdentifier stackTraceParameter2 = clause.stackTraceParameter;
-    stackTraceParameter2.element = new LocalVariableElementImpl(stackTraceParameter2);
+    SimpleIdentifier exceptionParameter = clause.exceptionParameter;
+    exceptionParameter.element = new LocalVariableElementImpl(exceptionParameter);
+    SimpleIdentifier stackTraceParameter = clause.stackTraceParameter;
+    stackTraceParameter.element = new LocalVariableElementImpl(stackTraceParameter);
     resolve(clause, _typeProvider.objectType, _typeProvider.stackTraceType, []);
     _listener.assertNoErrors();
   }
   void test_visitCatchClause_on_exception() {
     ClassElement exceptionElement = ElementFactory.classElement2("E", []);
     TypeName exceptionType = ASTFactory.typeName(exceptionElement, []);
     CatchClause clause = ASTFactory.catchClause4(exceptionType, "e", []);
-    SimpleIdentifier exceptionParameter2 = clause.exceptionParameter;
-    exceptionParameter2.element = new LocalVariableElementImpl(exceptionParameter2);
+    SimpleIdentifier exceptionParameter = clause.exceptionParameter;
+    exceptionParameter.element = new LocalVariableElementImpl(exceptionParameter);
     resolve(clause, exceptionElement.type, null, [exceptionElement]);
     _listener.assertNoErrors();
   }
   void test_visitCatchClause_on_exception_stackTrace() {
     ClassElement exceptionElement = ElementFactory.classElement2("E", []);
     TypeName exceptionType = ASTFactory.typeName(exceptionElement, []);
     ((exceptionType.name as SimpleIdentifier)).element = exceptionElement;
     CatchClause clause = ASTFactory.catchClause5(exceptionType, "e", "s", []);
-    SimpleIdentifier exceptionParameter2 = clause.exceptionParameter;
-    exceptionParameter2.element = new LocalVariableElementImpl(exceptionParameter2);
-    SimpleIdentifier stackTraceParameter2 = clause.stackTraceParameter;
-    stackTraceParameter2.element = new LocalVariableElementImpl(stackTraceParameter2);
+    SimpleIdentifier exceptionParameter = clause.exceptionParameter;
+    exceptionParameter.element = new LocalVariableElementImpl(exceptionParameter);
+    SimpleIdentifier stackTraceParameter = clause.stackTraceParameter;
+    stackTraceParameter.element = new LocalVariableElementImpl(stackTraceParameter);
     resolve(clause, exceptionElement.type, _typeProvider.stackTraceType, [exceptionElement]);
     _listener.assertNoErrors();
   }
   void test_visitClassDeclaration() {
     ClassElement elementA = ElementFactory.classElement2("A", []);
     ClassElement elementB = ElementFactory.classElement2("B", []);
     ClassElement elementC = ElementFactory.classElement2("C", []);
     ClassElement elementD = ElementFactory.classElement2("D", []);
-    ExtendsClause extendsClause2 = ASTFactory.extendsClause(ASTFactory.typeName(elementB, []));
-    WithClause withClause2 = ASTFactory.withClause([ASTFactory.typeName(elementC, [])]);
-    ImplementsClause implementsClause2 = ASTFactory.implementsClause([ASTFactory.typeName(elementD, [])]);
-    ClassDeclaration declaration = ASTFactory.classDeclaration(null, "A", null, extendsClause2, withClause2, implementsClause2, []);
+    ExtendsClause extendsClause = ASTFactory.extendsClause(ASTFactory.typeName(elementB, []));
+    WithClause withClause = ASTFactory.withClause([ASTFactory.typeName(elementC, [])]);
+    ImplementsClause implementsClause = ASTFactory.implementsClause([ASTFactory.typeName(elementD, [])]);
+    ClassDeclaration declaration = ASTFactory.classDeclaration(null, "A", null, extendsClause, withClause, implementsClause, []);
     declaration.name.element = elementA;
     resolveNode(declaration, [elementA, elementB, elementC, elementD]);
     JUnitTestCase.assertSame(elementB.type, elementA.supertype);
-    List<InterfaceType> mixins2 = elementA.mixins;
-    EngineTestCase.assertLength(1, mixins2);
-    JUnitTestCase.assertSame(elementC.type, mixins2[0]);
-    List<InterfaceType> interfaces2 = elementA.interfaces;
-    EngineTestCase.assertLength(1, interfaces2);
-    JUnitTestCase.assertSame(elementD.type, interfaces2[0]);
+    List<InterfaceType> mixins = elementA.mixins;
+    EngineTestCase.assertLength(1, mixins);
+    JUnitTestCase.assertSame(elementC.type, mixins[0]);
+    List<InterfaceType> interfaces = elementA.interfaces;
+    EngineTestCase.assertLength(1, interfaces);
+    JUnitTestCase.assertSame(elementD.type, interfaces[0]);
     _listener.assertNoErrors();
   }
   void test_visitClassTypeAlias() {
     ClassElement elementA = ElementFactory.classElement2("A", []);
     ClassElement elementB = ElementFactory.classElement2("B", []);
     ClassElement elementC = ElementFactory.classElement2("C", []);
     ClassElement elementD = ElementFactory.classElement2("D", []);
-    WithClause withClause2 = ASTFactory.withClause([ASTFactory.typeName(elementC, [])]);
-    ImplementsClause implementsClause2 = ASTFactory.implementsClause([ASTFactory.typeName(elementD, [])]);
-    ClassTypeAlias alias = ASTFactory.classTypeAlias("A", null, null, ASTFactory.typeName(elementB, []), withClause2, implementsClause2);
+    WithClause withClause = ASTFactory.withClause([ASTFactory.typeName(elementC, [])]);
+    ImplementsClause implementsClause = ASTFactory.implementsClause([ASTFactory.typeName(elementD, [])]);
+    ClassTypeAlias alias = ASTFactory.classTypeAlias("A", null, null, ASTFactory.typeName(elementB, []), withClause, implementsClause);
     alias.name.element = elementA;
     resolveNode(alias, [elementA, elementB, elementC, elementD]);
     JUnitTestCase.assertSame(elementB.type, elementA.supertype);
-    List<InterfaceType> mixins2 = elementA.mixins;
-    EngineTestCase.assertLength(1, mixins2);
-    JUnitTestCase.assertSame(elementC.type, mixins2[0]);
-    List<InterfaceType> interfaces2 = elementA.interfaces;
-    EngineTestCase.assertLength(1, interfaces2);
-    JUnitTestCase.assertSame(elementD.type, interfaces2[0]);
+    List<InterfaceType> mixins = elementA.mixins;
+    EngineTestCase.assertLength(1, mixins);
+    JUnitTestCase.assertSame(elementC.type, mixins[0]);
+    List<InterfaceType> interfaces = elementA.interfaces;
+    EngineTestCase.assertLength(1, interfaces);
+    JUnitTestCase.assertSame(elementD.type, interfaces[0]);
     _listener.assertNoErrors();
   }
   void test_visitSimpleFormalParameter_noType() {
     FormalParameter node = ASTFactory.simpleFormalParameter3("p");
     node.identifier.element = new ParameterElementImpl(ASTFactory.identifier3("p"));
     JUnitTestCase.assertSame(_typeProvider.dynamicType, resolve6(node, []));
     _listener.assertNoErrors();
   }
   void test_visitSimpleFormalParameter_type() {
-    InterfaceType intType2 = _typeProvider.intType;
-    ClassElement intElement = intType2.element;
+    InterfaceType intType = _typeProvider.intType;
+    ClassElement intElement = intType.element;
     FormalParameter node = ASTFactory.simpleFormalParameter4(ASTFactory.typeName(intElement, []), "p");
-    SimpleIdentifier identifier2 = node.identifier;
-    ParameterElementImpl element = new ParameterElementImpl(identifier2);
-    identifier2.element = element;
-    JUnitTestCase.assertSame(intType2, resolve6(node, [intElement]));
+    SimpleIdentifier identifier = node.identifier;
+    ParameterElementImpl element = new ParameterElementImpl(identifier);
+    identifier.element = element;
+    JUnitTestCase.assertSame(intType, resolve6(node, [intElement]));
     _listener.assertNoErrors();
   }
   void test_visitTypeName_noParameters_noArguments() {
     ClassElement classA = ElementFactory.classElement2("A", []);
-    TypeName typeName2 = ASTFactory.typeName(classA, []);
-    typeName2.type = null;
-    resolveNode(typeName2, [classA]);
-    JUnitTestCase.assertSame(classA.type, typeName2.type);
+    TypeName typeName = ASTFactory.typeName(classA, []);
+    typeName.type = null;
+    resolveNode(typeName, [classA]);
+    JUnitTestCase.assertSame(classA.type, typeName.type);
     _listener.assertNoErrors();
   }
   void test_visitTypeName_parameters_arguments() {
     ClassElement classA = ElementFactory.classElement2("A", ["E"]);
     ClassElement classB = ElementFactory.classElement2("B", []);
-    TypeName typeName2 = ASTFactory.typeName(classA, [ASTFactory.typeName(classB, [])]);
-    typeName2.type = null;
-    resolveNode(typeName2, [classA, classB]);
-    InterfaceType resultType = typeName2.type as InterfaceType;
+    TypeName typeName = ASTFactory.typeName(classA, [ASTFactory.typeName(classB, [])]);
+    typeName.type = null;
+    resolveNode(typeName, [classA, classB]);
+    InterfaceType resultType = typeName.type as InterfaceType;
     JUnitTestCase.assertSame(classA, resultType.element);
     List<Type2> resultArguments = resultType.typeArguments;
     EngineTestCase.assertLength(1, resultArguments);
     JUnitTestCase.assertSame(classB.type, resultArguments[0]);
     _listener.assertNoErrors();
   }
   void test_visitTypeName_parameters_noArguments() {
     ClassElement classA = ElementFactory.classElement2("A", ["E"]);
-    TypeName typeName2 = ASTFactory.typeName(classA, []);
-    typeName2.type = null;
-    resolveNode(typeName2, [classA]);
-    InterfaceType resultType = typeName2.type as InterfaceType;
+    TypeName typeName = ASTFactory.typeName(classA, []);
+    typeName.type = null;
+    resolveNode(typeName, [classA]);
+    InterfaceType resultType = typeName.type as InterfaceType;
     JUnitTestCase.assertSame(classA, resultType.element);
     List<Type2> resultArguments = resultType.typeArguments;
     EngineTestCase.assertLength(1, resultArguments);
     JUnitTestCase.assertSame(DynamicTypeImpl.instance, resultArguments[0]);
     _listener.assertNoErrors();
   }
   void test_visitTypeName_void() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     TypeName typeName = ASTFactory.typeName4("void", []);
     resolveNode(typeName, [classA]);
     JUnitTestCase.assertSame(VoidTypeImpl.instance, typeName.type);
     _listener.assertNoErrors();
   }
 
   /**
    * Analyze the given catch clause and assert that the types of the parameters have been set to the
    * given types. The types can be null if the catch clause does not have the corresponding
    * parameter.
    * @param node the catch clause to be analyzed
    * @param exceptionType the expected type of the exception parameter
    * @param stackTraceType the expected type of the stack trace parameter
    * @param definedElements the elements that are to be defined in the scope in which the element is
    * being resolved
    */
   void resolve(CatchClause node, InterfaceType exceptionType, InterfaceType stackTraceType, List<Element> definedElements) {
     resolveNode(node, definedElements);
-    SimpleIdentifier exceptionParameter2 = node.exceptionParameter;
-    if (exceptionParameter2 != null) {
-      JUnitTestCase.assertSame(exceptionType, exceptionParameter2.staticType);
+    SimpleIdentifier exceptionParameter = node.exceptionParameter;
+    if (exceptionParameter != null) {
+      JUnitTestCase.assertSame(exceptionType, exceptionParameter.staticType);
     }
-    SimpleIdentifier stackTraceParameter2 = node.stackTraceParameter;
-    if (stackTraceParameter2 != null) {
-      JUnitTestCase.assertSame(stackTraceType, stackTraceParameter2.staticType);
+    SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
+    if (stackTraceParameter != null) {
+      JUnitTestCase.assertSame(stackTraceType, stackTraceParameter.staticType);
     }
   }
 
   /**
    * Return the type associated with the given parameter after the static type analyzer has computed
    * a type for it.
    * @param node the parameter with which the type is associated
    * @param definedElements the elements that are to be defined in the scope in which the element is
    * being resolved
    * @return the type associated with the parameter
@@ skipping 3355 matching lines @@
   Object visitImportDirective(ImportDirective node) => null;
   Object visitLabel(Label node) => null;
   Object visitLibraryIdentifier(LibraryIdentifier node) => null;
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (node.staticType == null && identical(node.prefix.staticType, DynamicTypeImpl.instance)) {
       return null;
     }
     return super.visitPrefixedIdentifier(node);
   }
   Object visitSimpleIdentifier(SimpleIdentifier node) {
-    ASTNode parent2 = node.parent;
-    if (parent2 is MethodInvocation && identical(node, ((parent2 as MethodInvocation)).methodName)) {
+    ASTNode parent = node.parent;
+    if (parent is MethodInvocation && identical(node, ((parent as MethodInvocation)).methodName)) {
       return null;
-    } else if (parent2 is RedirectingConstructorInvocation && identical(node, ((parent2 as RedirectingConstructorInvocation)).constructorName)) {
+    } else if (parent is RedirectingConstructorInvocation && identical(node, ((parent as RedirectingConstructorInvocation)).constructorName)) {
       return null;
-    } else if (parent2 is SuperConstructorInvocation && identical(node, ((parent2 as SuperConstructorInvocation)).constructorName)) {
+    } else if (parent is SuperConstructorInvocation && identical(node, ((parent as SuperConstructorInvocation)).constructorName)) {
       return null;
-    } else if (parent2 is ConstructorName && identical(node, ((parent2 as ConstructorName)).name)) {
+    } else if (parent is ConstructorName && identical(node, ((parent as ConstructorName)).name)) {
       return null;
-    } else if (parent2 is ConstructorFieldInitializer && identical(node, ((parent2 as ConstructorFieldInitializer)).fieldName)) {
+    } else if (parent is ConstructorFieldInitializer && identical(node, ((parent as ConstructorFieldInitializer)).fieldName)) {
       return null;
     } else if (node.element is PrefixElement) {
       return null;
     }
     return super.visitSimpleIdentifier(node);
   }
   Object visitTypeName(TypeName node) {
     if (node.type == null) {
       _unresolvedTypes.add(node);
     } else {
       _resolvedTypeCount++;
     }
     return null;
   }
   String getFileName(ASTNode node) {
     if (node != null) {
-      ASTNode root2 = node.root;
-      if (root2 is CompilationUnit) {
-        CompilationUnit rootCU = (root2 as CompilationUnit);
+      ASTNode root = node.root;
+      if (root is CompilationUnit) {
+        CompilationUnit rootCU = (root as CompilationUnit);
         if (rootCU.element != null) {
           return rootCU.element.source.fullName;
         } else {
           return "<unknown file- CompilationUnit.getElement() returned null>";
         }
       } else {
         return "<unknown file- CompilationUnit.getRoot() is not a CompilationUnit>";
       }
     }
     return "<unknown file- ASTNode is null>";
@@ skipping 181 matching lines @@
   void fail_visitRedirectingConstructorInvocation() {
     JUnitTestCase.fail("Not yet tested");
     _listener.assertNoErrors();
   }
   void setUp() {
     _listener = new GatheringErrorListener();
     _typeProvider = new TestTypeProvider();
     _resolver = createResolver();
   }
   void test_lookUpMethodInInterfaces() {
-    InterfaceType intType2 = _typeProvider.intType;
+    InterfaceType intType = _typeProvider.intType;
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
-    MethodElement operator = ElementFactory.methodElement("[]", intType2, [intType2]);
+    MethodElement operator = ElementFactory.methodElement("[]", intType, [intType]);
     classA.methods = <MethodElement> [operator];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.interfaces = <InterfaceType> [classA.type];
     ClassElementImpl classC = ElementFactory.classElement2("C", []);
     classC.mixins = <InterfaceType> [classB.type];
     ClassElementImpl classD = ElementFactory.classElement("D", classC.type, []);
     SimpleIdentifier array = ASTFactory.identifier3("a");
     array.staticType = classD.type;
     IndexExpression expression = ASTFactory.indexExpression(array, ASTFactory.identifier3("i"));
     JUnitTestCase.assertSame(operator, resolve5(expression, []));
     _listener.assertNoErrors();
   }
   void test_visitAssignmentExpression_compound() {
-    InterfaceType intType2 = _typeProvider.intType;
+    InterfaceType intType = _typeProvider.intType;
     SimpleIdentifier leftHandSide = ASTFactory.identifier3("a");
-    leftHandSide.staticType = intType2;
+    leftHandSide.staticType = intType;
     AssignmentExpression assignment = ASTFactory.assignmentExpression(leftHandSide, TokenType.PLUS_EQ, ASTFactory.integer(1));
     resolveNode(assignment, []);
     JUnitTestCase.assertSame(getMethod(_typeProvider.numType, "+"), assignment.element);
     _listener.assertNoErrors();
   }
   void test_visitAssignmentExpression_simple() {
     AssignmentExpression expression = ASTFactory.assignmentExpression(ASTFactory.identifier3("x"), TokenType.EQ, ASTFactory.integer(0));
     resolveNode(expression, []);
     JUnitTestCase.assertNull(expression.element);
     _listener.assertNoErrors();
   }
   void test_visitBinaryExpression() {
-    InterfaceType numType2 = _typeProvider.numType;
+    InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier left = ASTFactory.identifier3("i");
-    left.staticType = numType2;
+    left.staticType = numType;
     BinaryExpression expression = ASTFactory.binaryExpression(left, TokenType.PLUS, ASTFactory.identifier3("j"));
     resolveNode(expression, []);
-    JUnitTestCase.assertEquals(getMethod(numType2, "+"), expression.element);
+    JUnitTestCase.assertEquals(getMethod(numType, "+"), expression.element);
     _listener.assertNoErrors();
   }
   void test_visitBreakStatement_withLabel() {
     String label = "loop";
     LabelElementImpl labelElement = new LabelElementImpl(ASTFactory.identifier3(label), false, false);
     BreakStatement statement = ASTFactory.breakStatement2(label);
     JUnitTestCase.assertSame(labelElement, resolve(statement, labelElement));
     _listener.assertNoErrors();
   }
   void test_visitBreakStatement_withoutLabel() {
@@ skipping 33 matching lines @@
     resolveStatement(statement, null);
     _listener.assertNoErrors();
   }
   void test_visitExportDirective_noCombinators() {
     ExportDirective directive = ASTFactory.exportDirective2(null, []);
     directive.element = ElementFactory.exportFor(ElementFactory.library(_definingLibrary.context, "lib"), []);
     resolveNode(directive, []);
     _listener.assertNoErrors();
   }
   void test_visitFieldFormalParameter() {
-    InterfaceType intType2 = _typeProvider.intType;
+    InterfaceType intType = _typeProvider.intType;
     String fieldName = "f";
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
-    classA.fields = <FieldElement> [ElementFactory.fieldElement(fieldName, false, false, false, intType2)];
+    classA.fields = <FieldElement> [ElementFactory.fieldElement(fieldName, false, false, false, intType)];
     FieldFormalParameter parameter = ASTFactory.fieldFormalParameter2(fieldName);
     parameter.identifier.element = ElementFactory.fieldFormalParameter(parameter.identifier);
     resolveInClass(parameter, classA);
-    JUnitTestCase.assertSame(intType2, parameter.element.type);
+    JUnitTestCase.assertSame(intType, parameter.element.type);
   }
   void test_visitImportDirective_noCombinators_noPrefix() {
     ImportDirective directive = ASTFactory.importDirective2(null, null, []);
     directive.element = ElementFactory.importFor(ElementFactory.library(_definingLibrary.context, "lib"), null, []);
     resolveNode(directive, []);
     _listener.assertNoErrors();
   }
   void test_visitImportDirective_noCombinators_prefix() {
     String prefixName = "p";
     ImportElement importElement = ElementFactory.importFor(ElementFactory.library(_definingLibrary.context, "lib"), ElementFactory.prefix(prefixName), []);
     _definingLibrary.imports = <ImportElement> [importElement];
     ImportDirective directive = ASTFactory.importDirective2(null, prefixName, []);
     directive.element = importElement;
     resolveNode(directive, []);
     _listener.assertNoErrors();
   }
   void test_visitIndexExpression_get() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
-    InterfaceType intType2 = _typeProvider.intType;
-    MethodElement getter = ElementFactory.methodElement("[]", intType2, [intType2]);
+    InterfaceType intType = _typeProvider.intType;
+    MethodElement getter = ElementFactory.methodElement("[]", intType, [intType]);
     classA.methods = <MethodElement> [getter];
     SimpleIdentifier array = ASTFactory.identifier3("a");
     array.staticType = classA.type;
     IndexExpression expression = ASTFactory.indexExpression(array, ASTFactory.identifier3("i"));
     JUnitTestCase.assertSame(getter, resolve5(expression, []));
     _listener.assertNoErrors();
   }
   void test_visitIndexExpression_set() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
-    InterfaceType intType2 = _typeProvider.intType;
-    MethodElement setter = ElementFactory.methodElement("[]=", intType2, [intType2]);
+    InterfaceType intType = _typeProvider.intType;
+    MethodElement setter = ElementFactory.methodElement("[]=", intType, [intType]);
     classA.methods = <MethodElement> [setter];
     SimpleIdentifier array = ASTFactory.identifier3("a");
     array.staticType = classA.type;
     IndexExpression expression = ASTFactory.indexExpression(array, ASTFactory.identifier3("i"));
     ASTFactory.assignmentExpression(expression, TokenType.EQ, ASTFactory.integer(0));
     JUnitTestCase.assertSame(setter, resolve5(expression, []));
     _listener.assertNoErrors();
   }
   void test_visitInstanceCreationExpression_named() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
@@ skipping 29 matching lines @@
     classA.constructors = <ConstructorElement> [constructor];
     ConstructorName name = ASTFactory.constructorName(ASTFactory.typeName(classA, []), constructorName);
     name.element = constructor;
     InstanceCreationExpression creation = ASTFactory.instanceCreationExpression(Keyword.NEW, name, [ASTFactory.namedExpression2(parameterName, ASTFactory.integer(0))]);
     resolveNode(creation, []);
     JUnitTestCase.assertSame(constructor, creation.element);
     JUnitTestCase.assertSame(parameter, ((creation.argumentList.arguments[0] as NamedExpression)).name.label.element);
     _listener.assertNoErrors();
   }
   void test_visitMethodInvocation() {
-    InterfaceType numType2 = _typeProvider.numType;
+    InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier left = ASTFactory.identifier3("i");
-    left.staticType = numType2;
+    left.staticType = numType;
     String methodName = "abs";
     MethodInvocation invocation = ASTFactory.methodInvocation(left, methodName, []);
     resolveNode(invocation, []);
-    JUnitTestCase.assertSame(getMethod(numType2, methodName), invocation.methodName.element);
+    JUnitTestCase.assertSame(getMethod(numType, methodName), invocation.methodName.element);
     _listener.assertNoErrors();
   }
   void test_visitMethodInvocation_namedParameter() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     String parameterName = "p";
     MethodElementImpl method = ElementFactory.methodElement(methodName, null, []);
     ParameterElement parameter = ElementFactory.namedParameter(parameterName);
     method.parameters = <ParameterElement> [parameter];
     classA.methods = <MethodElement> [method];
     SimpleIdentifier left = ASTFactory.identifier3("i");
     left.staticType = classA.type;
     MethodInvocation invocation = ASTFactory.methodInvocation(left, methodName, [ASTFactory.namedExpression2(parameterName, ASTFactory.integer(0))]);
     resolveNode(invocation, []);
     JUnitTestCase.assertSame(method, invocation.methodName.element);
     JUnitTestCase.assertSame(parameter, ((invocation.argumentList.arguments[0] as NamedExpression)).name.label.element);
     _listener.assertNoErrors();
   }
   void test_visitPostfixExpression() {
-    InterfaceType numType2 = _typeProvider.numType;
+    InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier operand = ASTFactory.identifier3("i");
-    operand.staticType = numType2;
+    operand.staticType = numType;
     PostfixExpression expression = ASTFactory.postfixExpression(operand, TokenType.PLUS_PLUS);
     resolveNode(expression, []);
-    JUnitTestCase.assertEquals(getMethod(numType2, "+"), expression.element);
+    JUnitTestCase.assertEquals(getMethod(numType, "+"), expression.element);
     _listener.assertNoErrors();
   }
   void test_visitPrefixedIdentifier_dynamic() {
-    Type2 dynamicType2 = _typeProvider.dynamicType;
+    Type2 dynamicType = _typeProvider.dynamicType;
     SimpleIdentifier target = ASTFactory.identifier3("a");
     VariableElementImpl variable = ElementFactory.localVariableElement(target);
-    variable.type = dynamicType2;
+    variable.type = dynamicType;
     target.element = variable;
-    target.staticType = dynamicType2;
-    PrefixedIdentifier identifier2 = ASTFactory.identifier(target, ASTFactory.identifier3("b"));
-    resolveNode(identifier2, []);
-    JUnitTestCase.assertNull(identifier2.element);
-    JUnitTestCase.assertNull(identifier2.identifier.element);
+    target.staticType = dynamicType;
+    PrefixedIdentifier identifier = ASTFactory.identifier(target, ASTFactory.identifier3("b"));
+    resolveNode(identifier, []);
+    JUnitTestCase.assertNull(identifier.element);
+    JUnitTestCase.assertNull(identifier.identifier.element);
     _listener.assertNoErrors();
   }
   void test_visitPrefixedIdentifier_nonDynamic() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "b";
     PropertyAccessorElement getter = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getter];
     SimpleIdentifier target = ASTFactory.identifier3("a");
     VariableElementImpl variable = ElementFactory.localVariableElement(target);
     variable.type = classA.type;
     target.element = variable;
     target.staticType = classA.type;
-    PrefixedIdentifier identifier2 = ASTFactory.identifier(target, ASTFactory.identifier3(getterName));
-    resolveNode(identifier2, []);
-    JUnitTestCase.assertSame(getter, identifier2.element);
-    JUnitTestCase.assertSame(getter, identifier2.identifier.element);
+    PrefixedIdentifier identifier = ASTFactory.identifier(target, ASTFactory.identifier3(getterName));
+    resolveNode(identifier, []);
+    JUnitTestCase.assertSame(getter, identifier.element);
+    JUnitTestCase.assertSame(getter, identifier.identifier.element);
     _listener.assertNoErrors();
   }
   void test_visitPrefixExpression() {
-    InterfaceType numType2 = _typeProvider.numType;
+    InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier operand = ASTFactory.identifier3("i");
-    operand.staticType = numType2;
+    operand.staticType = numType;
     PrefixExpression expression = ASTFactory.prefixExpression(TokenType.PLUS_PLUS, operand);
     resolveNode(expression, []);
-    JUnitTestCase.assertEquals(getMethod(numType2, "+"), expression.element);
+    JUnitTestCase.assertEquals(getMethod(numType, "+"), expression.element);
     _listener.assertNoErrors();
   }
   void test_visitPropertyAccess_getter_identifier() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "b";
     PropertyAccessorElement getter = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getter];
     SimpleIdentifier target = ASTFactory.identifier3("a");
     target.staticType = classA.type;
     PropertyAccess access = ASTFactory.propertyAccess2(target, getterName);
@@ skipping 21 matching lines @@
     classA.accessors = <PropertyAccessorElement> [setter];
     ThisExpression target = ASTFactory.thisExpression();
     target.staticType = classA.type;
     PropertyAccess access = ASTFactory.propertyAccess2(target, setterName);
     ASTFactory.assignmentExpression(access, TokenType.EQ, ASTFactory.integer(0));
     resolveNode(access, []);
     JUnitTestCase.assertSame(setter, access.propertyName.element);
     _listener.assertNoErrors();
   }
   void test_visitSimpleIdentifier_classScope() {
-    InterfaceType doubleType2 = _typeProvider.doubleType;
+    InterfaceType doubleType = _typeProvider.doubleType;
     String fieldName = "NAN";
     SimpleIdentifier node = ASTFactory.identifier3(fieldName);
-    resolveInClass(node, doubleType2.element);
-    JUnitTestCase.assertEquals(getGetter(doubleType2, fieldName), node.element);
+    resolveInClass(node, doubleType.element);
+    JUnitTestCase.assertEquals(getGetter(doubleType, fieldName), node.element);
     _listener.assertNoErrors();
   }
   void test_visitSimpleIdentifier_lexicalScope() {
     SimpleIdentifier node = ASTFactory.identifier3("i");
     VariableElementImpl element = ElementFactory.localVariableElement(node);
     JUnitTestCase.assertSame(element, resolve4(node, [element]));
     _listener.assertNoErrors();
   }
   void test_visitSimpleIdentifier_lexicalScope_field_setter() {
-    InterfaceType intType2 = _typeProvider.intType;
+    InterfaceType intType = _typeProvider.intType;
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String fieldName = "a";
-    FieldElement field = ElementFactory.fieldElement(fieldName, false, false, false, intType2);
+    FieldElement field = ElementFactory.fieldElement(fieldName, false, false, false, intType);
     classA.fields = <FieldElement> [field];
     classA.accessors = <PropertyAccessorElement> [field.getter, field.setter];
     SimpleIdentifier node = ASTFactory.identifier3(fieldName);
     ASTFactory.assignmentExpression(node, TokenType.EQ, ASTFactory.integer(0));
     resolveInClass(node, classA);
-    Element element2 = node.element;
-    EngineTestCase.assertInstanceOf(PropertyAccessorElement, element2);
-    JUnitTestCase.assertTrue(((element2 as PropertyAccessorElement)).isSetter());
+    Element element = node.element;
+    EngineTestCase.assertInstanceOf(PropertyAccessorElement, element);
+    JUnitTestCase.assertTrue(((element as PropertyAccessorElement)).isSetter());
     _listener.assertNoErrors();
   }
   void test_visitSuperConstructorInvocation() {
     ClassElementImpl superclass = ElementFactory.classElement2("A", []);
     ConstructorElementImpl superConstructor = ElementFactory.constructorElement(superclass, null);
     superclass.constructors = <ConstructorElement> [superConstructor];
     ClassElementImpl subclass = ElementFactory.classElement("B", superclass.type, []);
     ConstructorElementImpl subConstructor = ElementFactory.constructorElement(subclass, null);
     subclass.constructors = <ConstructorElement> [subConstructor];
     SuperConstructorInvocation invocation = ASTFactory.superConstructorInvocation([]);
@@ skipping 332 matching lines @@
     manager.exitScope();
     try {
       manager.exitScope();
       JUnitTestCase.fail("Expected IllegalStateException");
     } on IllegalStateException catch (exception) {
     }
   }
   void test_getType_enclosedOverride() {
     TypeOverrideManager manager = new TypeOverrideManager();
     LocalVariableElementImpl element = ElementFactory.localVariableElement2("v");
-    InterfaceType type2 = ElementFactory.classElement2("C", []).type;
+    InterfaceType type = ElementFactory.classElement2("C", []).type;
     manager.enterScope();
-    manager.setType(element, type2);
+    manager.setType(element, type);
     manager.enterScope();
-    JUnitTestCase.assertSame(type2, manager.getType(element));
+    JUnitTestCase.assertSame(type, manager.getType(element));
   }
   void test_getType_immediateOverride() {
     TypeOverrideManager manager = new TypeOverrideManager();
     LocalVariableElementImpl element = ElementFactory.localVariableElement2("v");
-    InterfaceType type2 = ElementFactory.classElement2("C", []).type;
+    InterfaceType type = ElementFactory.classElement2("C", []).type;
     manager.enterScope();
-    manager.setType(element, type2);
-    JUnitTestCase.assertSame(type2, manager.getType(element));
+    manager.setType(element, type);
+    JUnitTestCase.assertSame(type, manager.getType(element));
   }
   void test_getType_noOverride() {
     TypeOverrideManager manager = new TypeOverrideManager();
     manager.enterScope();
     JUnitTestCase.assertNull(manager.getType(ElementFactory.localVariableElement2("v")));
   }
   void test_getType_noScope() {
     TypeOverrideManager manager = new TypeOverrideManager();
     JUnitTestCase.assertNull(manager.getType(ElementFactory.localVariableElement2("v")));
   }
@@ skipping 1645 matching lines @@
  * for testing purposes.
  */
 class AnalysisContextFactory {
 
   /**
    * Create an analysis context that has a fake core library already resolved.
    * @return the analysis context that was created
    */
   static AnalysisContextImpl contextWithCore() {
     AnalysisContextImpl sdkContext = DirectoryBasedDartSdk.defaultSdk.context as AnalysisContextImpl;
-    SourceFactory sourceFactory2 = sdkContext.sourceFactory;
+    SourceFactory sourceFactory = sdkContext.sourceFactory;
     TestTypeProvider provider = new TestTypeProvider();
     CompilationUnitElementImpl coreUnit = new CompilationUnitElementImpl("core.dart");
-    Source coreSource = sourceFactory2.forUri(DartSdk.DART_CORE);
+    Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
     sdkContext.setContents(coreSource, "");
     coreUnit.source = coreSource;
     coreUnit.types = <ClassElement> [provider.boolType.element, provider.doubleType.element, provider.functionType.element, provider.intType.element, provider.listType.element, provider.mapType.element, provider.numType.element, provider.objectType.element, provider.stackTraceType.element, provider.stringType.element, provider.typeType.element];
     LibraryElementImpl coreLibrary = new LibraryElementImpl(sdkContext, ASTFactory.libraryIdentifier2(["dart", "core"]));
     coreLibrary.definingCompilationUnit = coreUnit;
     CompilationUnitElementImpl htmlUnit = new CompilationUnitElementImpl("html_dartium.dart");
-    Source htmlSource = sourceFactory2.forUri(DartSdk.DART_HTML);
+    Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
     sdkContext.setContents(htmlSource, "");
     htmlUnit.source = htmlSource;
     ClassElementImpl elementElement = ElementFactory.classElement2("Element", []);
     InterfaceType elementType = elementElement.type;
     ClassElementImpl documentElement = ElementFactory.classElement("Document", elementType, []);
     ClassElementImpl htmlDocumentElement = ElementFactory.classElement("HtmlDocument", documentElement.type, []);
     htmlDocumentElement.methods = <MethodElement> [ElementFactory.methodElement("query", elementType, <Type2> [provider.stringType])];
     htmlUnit.types = <ClassElement> [ElementFactory.classElement("AnchorElement", elementType, []), ElementFactory.classElement("BodyElement", elementType, []), ElementFactory.classElement("ButtonElement", elementType, []), ElementFactory.classElement("DivElement", elementType, []), documentElement, elementElement, htmlDocumentElement, ElementFactory.classElement("InputElement", elementType, []), ElementFactory.classElement("SelectElement", elementType, [])];
     htmlUnit.functions = <FunctionElement> [ElementFactory.functionElement3("query", elementElement, <ClassElement> [provider.stringType.element], ClassElementImpl.EMPTY_ARRAY)];
     TopLevelVariableElementImpl document = ElementFactory.topLevelVariableElement3("document", true, htmlDocumentElement.type);
     htmlUnit.topLevelVariables = <TopLevelVariableElement> [document];
     htmlUnit.accessors = <PropertyAccessorElement> [document.getter];
     LibraryElementImpl htmlLibrary = new LibraryElementImpl(sdkContext, ASTFactory.libraryIdentifier2(["dart", "dom", "html"]));
     htmlLibrary.definingCompilationUnit = htmlUnit;
     Map<Source, LibraryElement> elementMap = new Map<Source, LibraryElement>();
     elementMap[coreSource] = coreLibrary;
     elementMap[htmlSource] = htmlLibrary;
     sdkContext.recordLibraryElements(elementMap);
     AnalysisContextImpl context = new DelegatingAnalysisContextImpl();
-    sourceFactory2 = new SourceFactory.con2([new DartUriResolver(sdkContext.sourceFactory.dartSdk), new FileUriResolver()]);
-    context.sourceFactory = sourceFactory2;
+    sourceFactory = new SourceFactory.con2([new DartUriResolver(sdkContext.sourceFactory.dartSdk), new FileUriResolver()]);
+    context.sourceFactory = sourceFactory;
     return context;
   }
 }
 class LibraryImportScopeTest extends ResolverTestCase {
   void test_conflictingImports() {
     AnalysisContext context = new AnalysisContextImpl();
     String typeNameA = "A";
     String typeNameB = "B";
     String typeNameC = "C";
     ClassElement typeA = ElementFactory.classElement2(typeNameA, []);
@@ skipping 11 matching lines @@
     {
       GatheringErrorListener errorListener = new GatheringErrorListener();
       Scope scope = new LibraryImportScope(importingLibrary, errorListener);
       JUnitTestCase.assertEquals(typeA, scope.lookup(ASTFactory.identifier3(typeNameA), importingLibrary));
       errorListener.assertNoErrors();
       JUnitTestCase.assertEquals(typeC, scope.lookup(ASTFactory.identifier3(typeNameC), importingLibrary));
       errorListener.assertNoErrors();
       Element element = scope.lookup(ASTFactory.identifier3(typeNameB), importingLibrary);
       errorListener.assertErrors2([CompileTimeErrorCode.AMBIGUOUS_IMPORT]);
       EngineTestCase.assertInstanceOf(MultiplyDefinedElement, element);
-      List<Element> conflictingElements2 = ((element as MultiplyDefinedElement)).conflictingElements;
-      JUnitTestCase.assertEquals(typeB1, conflictingElements2[0]);
-      JUnitTestCase.assertEquals(typeB2, conflictingElements2[1]);
-      JUnitTestCase.assertEquals(2, conflictingElements2.length);
+      List<Element> conflictingElements = ((element as MultiplyDefinedElement)).conflictingElements;
+      JUnitTestCase.assertEquals(typeB1, conflictingElements[0]);
+      JUnitTestCase.assertEquals(typeB2, conflictingElements[1]);
+      JUnitTestCase.assertEquals(2, conflictingElements.length);
     }
     {
       GatheringErrorListener errorListener = new GatheringErrorListener();
       Scope scope = new LibraryImportScope(importingLibrary, errorListener);
       Identifier identifier = ASTFactory.identifier3(typeNameB);
       ASTFactory.methodDeclaration(null, ASTFactory.typeName3(identifier, []), null, null, ASTFactory.identifier3("foo"), null);
       Element element = scope.lookup(identifier, importingLibrary);
       errorListener.assertErrors2([StaticWarningCode.AMBIGUOUS_IMPORT]);
       EngineTestCase.assertInstanceOf(MultiplyDefinedElement, element);
     }
@@ skipping 168 matching lines @@
       _wrongTypedNodes.add(node);
     }
     return null;
   }
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     node.visitChildren(this);
     return checkResolved2(node, node.element, FunctionElement);
   }
   Object visitImportDirective(ImportDirective node) {
     checkResolved2(node, node.element, ImportElement);
-    SimpleIdentifier prefix2 = node.prefix;
-    if (prefix2 == null) {
+    SimpleIdentifier prefix = node.prefix;
+    if (prefix == null) {
       return null;
     }
-    return checkResolved2(prefix2, prefix2.element, PrefixElement);
+    return checkResolved2(prefix, prefix.element, PrefixElement);
   }
   Object visitIndexExpression(IndexExpression node) {
     node.visitChildren(this);
     return checkResolved2(node, node.element, MethodElement);
   }
   Object visitLibraryDirective(LibraryDirective node) => checkResolved2(node, node.element, LibraryElement);
   Object visitPartDirective(PartDirective node) => checkResolved2(node, node.element, CompilationUnitElement);
   Object visitPartOfDirective(PartOfDirective node) => checkResolved2(node, node.element, LibraryElement);
   Object visitPostfixExpression(PostfixExpression node) {
     node.visitChildren(this);
@@ skipping 26 matching lines @@
       }
     } else if (expectedClass != null) {
       if (!isInstanceOf(element, expectedClass)) {
         _wrongTypedNodes.add(node);
       }
     }
     return null;
   }
   String getFileName(ASTNode node) {
     if (node != null) {
-      ASTNode root2 = node.root;
-      if (root2 is CompilationUnit) {
-        CompilationUnit rootCU = (root2 as CompilationUnit);
+      ASTNode root = node.root;
+      if (root is CompilationUnit) {
+        CompilationUnit rootCU = (root as CompilationUnit);
         if (rootCU.element != null) {
           return rootCU.element.source.fullName;
         } else {
           return "<unknown file- CompilationUnit.getElement() returned null>";
         }
       } else {
         return "<unknown file- CompilationUnit.getRoot() is not a CompilationUnit>";
       }
     }
     return "<unknown file- ASTNode is null>";
@@ skipping 113 matching lines @@
   }
   void test_visitAsExpression() {
     ClassElement superclass = ElementFactory.classElement2("A", []);
     InterfaceType superclassType = superclass.type;
     ClassElement subclass = ElementFactory.classElement("B", superclassType, []);
     Expression node = ASTFactory.asExpression(ASTFactory.thisExpression(), ASTFactory.typeName(subclass, []));
     JUnitTestCase.assertSame(subclass.type, analyze2(node, superclassType));
     _listener.assertNoErrors();
   }
   void test_visitAssignmentExpression_compound() {
-    InterfaceType numType2 = _typeProvider.numType;
+    InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier identifier = resolvedVariable(_typeProvider.intType, "i");
     AssignmentExpression node = ASTFactory.assignmentExpression(identifier, TokenType.PLUS_EQ, resolvedInteger(1));
-    MethodElement plusMethod = getMethod(numType2, "+");
+    MethodElement plusMethod = getMethod(numType, "+");
     node.staticElement = plusMethod;
     node.element = plusMethod;
-    JUnitTestCase.assertSame(numType2, analyze(node));
+    JUnitTestCase.assertSame(numType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitAssignmentExpression_simple() {
-    InterfaceType intType2 = _typeProvider.intType;
-    Expression node = ASTFactory.assignmentExpression(resolvedVariable(intType2, "i"), TokenType.EQ, resolvedInteger(0));
-    JUnitTestCase.assertSame(intType2, analyze(node));
+    InterfaceType intType = _typeProvider.intType;
+    Expression node = ASTFactory.assignmentExpression(resolvedVariable(intType, "i"), TokenType.EQ, resolvedInteger(0));
+    JUnitTestCase.assertSame(intType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitBinaryExpression_equals() {
     Expression node = ASTFactory.binaryExpression(resolvedInteger(2), TokenType.EQ_EQ, resolvedInteger(3));
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitBinaryExpression_logicalAnd() {
     Expression node = ASTFactory.binaryExpression(ASTFactory.booleanLiteral(false), TokenType.AMPERSAND_AMPERSAND, ASTFactory.booleanLiteral(true));
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
@@ skipping 57 matching lines @@
     Expression node = ASTFactory.conditionalExpression(ASTFactory.booleanLiteral(true), resolvedInteger(1), resolvedInteger(0));
     JUnitTestCase.assertSame(_typeProvider.intType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitDoubleLiteral() {
     Expression node = ASTFactory.doubleLiteral(4.33);
     JUnitTestCase.assertSame(_typeProvider.doubleType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitFunctionExpression_named_block() {
-    Type2 dynamicType2 = _typeProvider.dynamicType;
+    Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("p1"), resolvedInteger(0));
-    setType(p1, dynamicType2);
+    setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("p2"), resolvedInteger(0));
-    setType(p2, dynamicType2);
+    setType(p2, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.blockFunctionBody([]));
     analyze3(p1);
     analyze3(p2);
     Type2 resultType = analyze(node);
     Map<String, Type2> expectedNamedTypes = new Map<String, Type2>();
-    expectedNamedTypes["p1"] = dynamicType2;
-    expectedNamedTypes["p2"] = dynamicType2;
-    assertFunctionType(dynamicType2, null, null, expectedNamedTypes, resultType);
+    expectedNamedTypes["p1"] = dynamicType;
+    expectedNamedTypes["p2"] = dynamicType;
+    assertFunctionType(dynamicType, null, null, expectedNamedTypes, resultType);
     _listener.assertNoErrors();
   }
   void test_visitFunctionExpression_named_expression() {
-    Type2 dynamicType2 = _typeProvider.dynamicType;
+    Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p = ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("p"), resolvedInteger(0));
-    setType(p, dynamicType2);
+    setType(p, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p]), ASTFactory.expressionFunctionBody(resolvedInteger(0)));
     analyze3(p);
     Type2 resultType = analyze(node);
     Map<String, Type2> expectedNamedTypes = new Map<String, Type2>();
-    expectedNamedTypes["p"] = dynamicType2;
+    expectedNamedTypes["p"] = dynamicType;
     assertFunctionType(_typeProvider.intType, null, null, expectedNamedTypes, resultType);
     _listener.assertNoErrors();
   }
   void test_visitFunctionExpression_normal_block() {
-    Type2 dynamicType2 = _typeProvider.dynamicType;
+    Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.simpleFormalParameter3("p1");
-    setType(p1, dynamicType2);
+    setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.simpleFormalParameter3("p2");
-    setType(p2, dynamicType2);
+    setType(p2, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.blockFunctionBody([]));
     analyze3(p1);
     analyze3(p2);
     Type2 resultType = analyze(node);
-    assertFunctionType(dynamicType2, <Type2> [dynamicType2, dynamicType2], null, null, resultType);
+    assertFunctionType(dynamicType, <Type2> [dynamicType, dynamicType], null, null, resultType);
     _listener.assertNoErrors();
   }
   void test_visitFunctionExpression_normal_expression() {
-    Type2 dynamicType2 = _typeProvider.dynamicType;
+    Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p = ASTFactory.simpleFormalParameter3("p");
-    setType(p, dynamicType2);
+    setType(p, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p]), ASTFactory.expressionFunctionBody(resolvedInteger(0)));
     analyze3(p);
     Type2 resultType = analyze(node);
-    assertFunctionType(_typeProvider.intType, <Type2> [dynamicType2], null, null, resultType);
+    assertFunctionType(_typeProvider.intType, <Type2> [dynamicType], null, null, resultType);
     _listener.assertNoErrors();
   }
   void test_visitFunctionExpression_normalAndNamed_block() {
-    Type2 dynamicType2 = _typeProvider.dynamicType;
+    Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.simpleFormalParameter3("p1");
-    setType(p1, dynamicType2);
+    setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("p2"), resolvedInteger(0));
-    setType(p2, dynamicType2);
+    setType(p2, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.blockFunctionBody([]));
     analyze3(p2);
     Type2 resultType = analyze(node);
     Map<String, Type2> expectedNamedTypes = new Map<String, Type2>();
-    expectedNamedTypes["p2"] = dynamicType2;
-    assertFunctionType(dynamicType2, <Type2> [dynamicType2], null, expectedNamedTypes, resultType);
+    expectedNamedTypes["p2"] = dynamicType;
+    assertFunctionType(dynamicType, <Type2> [dynamicType], null, expectedNamedTypes, resultType);
     _listener.assertNoErrors();
   }
   void test_visitFunctionExpression_normalAndNamed_expression() {
-    Type2 dynamicType2 = _typeProvider.dynamicType;
+    Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.simpleFormalParameter3("p1");
-    setType(p1, dynamicType2);
+    setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("p2"), resolvedInteger(0));
-    setType(p2, dynamicType2);
+    setType(p2, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.expressionFunctionBody(resolvedInteger(0)));
     analyze3(p2);
     Type2 resultType = analyze(node);
     Map<String, Type2> expectedNamedTypes = new Map<String, Type2>();
-    expectedNamedTypes["p2"] = dynamicType2;
-    assertFunctionType(_typeProvider.intType, <Type2> [dynamicType2], null, expectedNamedTypes, resultType);
+    expectedNamedTypes["p2"] = dynamicType;
+    assertFunctionType(_typeProvider.intType, <Type2> [dynamicType], null, expectedNamedTypes, resultType);
     _listener.assertNoErrors();
   }
   void test_visitFunctionExpression_normalAndPositional_block() {
-    Type2 dynamicType2 = _typeProvider.dynamicType;
+    Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.simpleFormalParameter3("p1");
-    setType(p1, dynamicType2);
+    setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("p2"), resolvedInteger(0));
-    setType(p2, dynamicType2);
+    setType(p2, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.blockFunctionBody([]));
     analyze3(p1);
     analyze3(p2);
     Type2 resultType = analyze(node);
-    assertFunctionType(dynamicType2, <Type2> [dynamicType2], <Type2> [dynamicType2], null, resultType);
+    assertFunctionType(dynamicType, <Type2> [dynamicType], <Type2> [dynamicType], null, resultType);
     _listener.assertNoErrors();
   }
   void test_visitFunctionExpression_normalAndPositional_expression() {
-    Type2 dynamicType2 = _typeProvider.dynamicType;
+    Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.simpleFormalParameter3("p1");
-    setType(p1, dynamicType2);
+    setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("p2"), resolvedInteger(0));
-    setType(p2, dynamicType2);
+    setType(p2, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.expressionFunctionBody(resolvedInteger(0)));
     analyze3(p1);
     analyze3(p2);
     Type2 resultType = analyze(node);
-    assertFunctionType(_typeProvider.intType, <Type2> [dynamicType2], <Type2> [dynamicType2], null, resultType);
+    assertFunctionType(_typeProvider.intType, <Type2> [dynamicType], <Type2> [dynamicType], null, resultType);
     _listener.assertNoErrors();
   }
   void test_visitFunctionExpression_positional_block() {
-    Type2 dynamicType2 = _typeProvider.dynamicType;
+    Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("p1"), resolvedInteger(0));
-    setType(p1, dynamicType2);
+    setType(p1, dynamicType);
     FormalParameter p2 = ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("p2"), resolvedInteger(0));
-    setType(p2, dynamicType2);
+    setType(p2, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p1, p2]), ASTFactory.blockFunctionBody([]));
     analyze3(p1);
     analyze3(p2);
     Type2 resultType = analyze(node);
-    assertFunctionType(dynamicType2, null, <Type2> [dynamicType2, dynamicType2], null, resultType);
+    assertFunctionType(dynamicType, null, <Type2> [dynamicType, dynamicType], null, resultType);
     _listener.assertNoErrors();
   }
   void test_visitFunctionExpression_positional_expression() {
-    Type2 dynamicType2 = _typeProvider.dynamicType;
+    Type2 dynamicType = _typeProvider.dynamicType;
     FormalParameter p = ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("p"), resolvedInteger(0));
-    setType(p, dynamicType2);
+    setType(p, dynamicType);
     FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParameterList([p]), ASTFactory.expressionFunctionBody(resolvedInteger(0)));
     analyze3(p);
     Type2 resultType = analyze(node);
-    assertFunctionType(_typeProvider.intType, null, <Type2> [dynamicType2], null, resultType);
+    assertFunctionType(_typeProvider.intType, null, <Type2> [dynamicType], null, resultType);
     _listener.assertNoErrors();
   }
   void test_visitIndexExpression_getter() {
-    InterfaceType listType2 = _typeProvider.listType;
-    SimpleIdentifier identifier = resolvedVariable(listType2, "a");
+    InterfaceType listType = _typeProvider.listType;
+    SimpleIdentifier identifier = resolvedVariable(listType, "a");
     IndexExpression node = ASTFactory.indexExpression(identifier, resolvedInteger(2));
-    MethodElement indexMethod = listType2.element.methods[0];
+    MethodElement indexMethod = listType.element.methods[0];
     node.staticElement = indexMethod;
     node.element = indexMethod;
-    JUnitTestCase.assertSame(listType2.typeArguments[0], analyze(node));
+    JUnitTestCase.assertSame(listType.typeArguments[0], analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitIndexExpression_setter() {
-    InterfaceType listType2 = _typeProvider.listType;
-    SimpleIdentifier identifier = resolvedVariable(listType2, "a");
+    InterfaceType listType = _typeProvider.listType;
+    SimpleIdentifier identifier = resolvedVariable(listType, "a");
     IndexExpression node = ASTFactory.indexExpression(identifier, resolvedInteger(2));
-    MethodElement indexMethod = listType2.element.methods[1];
+    MethodElement indexMethod = listType.element.methods[1];
     node.staticElement = indexMethod;
     node.element = indexMethod;
     ASTFactory.assignmentExpression(node, TokenType.EQ, ASTFactory.integer(0));
-    JUnitTestCase.assertSame(listType2.typeArguments[0], analyze(node));
+    JUnitTestCase.assertSame(listType.typeArguments[0], analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitIndexExpression_typeParameters() {
-    InterfaceType intType2 = _typeProvider.intType;
-    InterfaceType listType2 = _typeProvider.listType;
-    MethodElement methodElement = getMethod(listType2, "[]");
+    InterfaceType intType = _typeProvider.intType;
+    InterfaceType listType = _typeProvider.listType;
+    MethodElement methodElement = getMethod(listType, "[]");
     SimpleIdentifier identifier = ASTFactory.identifier3("list");
-    InterfaceType listOfIntType = listType2.substitute5(<Type2> [intType2]);
+    InterfaceType listOfIntType = listType.substitute5(<Type2> [intType]);
     identifier.staticType = listOfIntType;
-    IndexExpression indexExpression2 = ASTFactory.indexExpression(identifier, ASTFactory.integer(0));
+    IndexExpression indexExpression = ASTFactory.indexExpression(identifier, ASTFactory.integer(0));
     MethodElement indexMethod = MethodMember.from(methodElement, listOfIntType);
-    indexExpression2.staticElement = indexMethod;
-    indexExpression2.element = indexMethod;
-    JUnitTestCase.assertSame(intType2, analyze(indexExpression2));
+    indexExpression.staticElement = indexMethod;
+    indexExpression.element = indexMethod;
+    JUnitTestCase.assertSame(intType, analyze(indexExpression));
     _listener.assertNoErrors();
   }
   void test_visitIndexExpression_typeParameters_inSetterContext() {
-    InterfaceType intType2 = _typeProvider.intType;
-    InterfaceType listType2 = _typeProvider.listType;
-    MethodElement methodElement = getMethod(listType2, "[]=");
+    InterfaceType intType = _typeProvider.intType;
+    InterfaceType listType = _typeProvider.listType;
+    MethodElement methodElement = getMethod(listType, "[]=");
     SimpleIdentifier identifier = ASTFactory.identifier3("list");
-    InterfaceType listOfIntType = listType2.substitute5(<Type2> [intType2]);
+    InterfaceType listOfIntType = listType.substitute5(<Type2> [intType]);
     identifier.staticType = listOfIntType;
-    IndexExpression indexExpression2 = ASTFactory.indexExpression(identifier, ASTFactory.integer(0));
+    IndexExpression indexExpression = ASTFactory.indexExpression(identifier, ASTFactory.integer(0));
     MethodElement indexMethod = MethodMember.from(methodElement, listOfIntType);
-    indexExpression2.staticElement = indexMethod;
-    indexExpression2.element = indexMethod;
-    ASTFactory.assignmentExpression(indexExpression2, TokenType.EQ, ASTFactory.integer(0));
-    JUnitTestCase.assertSame(intType2, analyze(indexExpression2));
+    indexExpression.staticElement = indexMethod;
+    indexExpression.element = indexMethod;
+    ASTFactory.assignmentExpression(indexExpression, TokenType.EQ, ASTFactory.integer(0));
+    JUnitTestCase.assertSame(intType, analyze(indexExpression));
     _listener.assertNoErrors();
   }
   void test_visitInstanceCreationExpression_named() {
     ClassElementImpl classElement = ElementFactory.classElement2("C", []);
     String constructorName = "m";
     ConstructorElementImpl constructor = ElementFactory.constructorElement(classElement, constructorName);
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
     constructorType.returnType = classElement.type;
     constructor.type = constructorType;
     classElement.constructors = <ConstructorElement> [constructor];
     InstanceCreationExpression node = ASTFactory.instanceCreationExpression2(null, ASTFactory.typeName(classElement, []), [ASTFactory.identifier3(constructorName)]);
     node.element = constructor;
     JUnitTestCase.assertSame(classElement.type, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitInstanceCreationExpression_typeParameters() {
     ClassElementImpl elementC = ElementFactory.classElement2("C", ["E"]);
     ClassElementImpl elementI = ElementFactory.classElement2("I", []);
     ConstructorElementImpl constructor = ElementFactory.constructorElement(elementC, null);
     elementC.constructors = <ConstructorElement> [constructor];
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
     constructorType.returnType = elementC.type;
     constructor.type = constructorType;
-    TypeName typeName2 = ASTFactory.typeName(elementC, [ASTFactory.typeName(elementI, [])]);
-    typeName2.type = elementC.type.substitute5(<Type2> [elementI.type]);
-    InstanceCreationExpression node = ASTFactory.instanceCreationExpression2(null, typeName2, []);
+    TypeName typeName = ASTFactory.typeName(elementC, [ASTFactory.typeName(elementI, [])]);
+    typeName.type = elementC.type.substitute5(<Type2> [elementI.type]);
+    InstanceCreationExpression node = ASTFactory.instanceCreationExpression2(null, typeName, []);
     node.element = constructor;
     InterfaceType interfaceType = analyze(node) as InterfaceType;
     List<Type2> typeArgs = interfaceType.typeArguments;
     JUnitTestCase.assertEquals(1, typeArgs.length);
     JUnitTestCase.assertEquals(elementI.type, typeArgs[0]);
     _listener.assertNoErrors();
   }
   void test_visitInstanceCreationExpression_unnamed() {
     ClassElementImpl classElement = ElementFactory.classElement2("C", []);
     ConstructorElementImpl constructor = ElementFactory.constructorElement(classElement, null);
@@ skipping 64 matching lines @@
     PostfixExpression node = ASTFactory.postfixExpression(resolvedInteger(0), TokenType.MINUS_MINUS);
     JUnitTestCase.assertSame(_typeProvider.intType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitPostfixExpression_plusPlus() {
     PostfixExpression node = ASTFactory.postfixExpression(resolvedInteger(0), TokenType.PLUS_PLUS);
     JUnitTestCase.assertSame(_typeProvider.intType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitPrefixedIdentifier_getter() {
-    Type2 boolType2 = _typeProvider.boolType;
-    PropertyAccessorElementImpl getter = ElementFactory.getterElement("b", false, boolType2);
+    Type2 boolType = _typeProvider.boolType;
+    PropertyAccessorElementImpl getter = ElementFactory.getterElement("b", false, boolType);
     PrefixedIdentifier node = ASTFactory.identifier5("a", "b");
     node.identifier.element = getter;
-    JUnitTestCase.assertSame(boolType2, analyze(node));
+    JUnitTestCase.assertSame(boolType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitPrefixedIdentifier_setter() {
-    Type2 boolType2 = _typeProvider.boolType;
-    FieldElementImpl field = ElementFactory.fieldElement("b", false, false, false, boolType2);
-    PropertyAccessorElement setter2 = field.setter;
+    Type2 boolType = _typeProvider.boolType;
+    FieldElementImpl field = ElementFactory.fieldElement("b", false, false, false, boolType);
+    PropertyAccessorElement setter = field.setter;
     PrefixedIdentifier node = ASTFactory.identifier5("a", "b");
-    node.identifier.element = setter2;
-    JUnitTestCase.assertSame(boolType2, analyze(node));
+    node.identifier.element = setter;
+    JUnitTestCase.assertSame(boolType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitPrefixedIdentifier_variable() {
     VariableElementImpl variable = ElementFactory.localVariableElement2("b");
     variable.type = _typeProvider.boolType;
     PrefixedIdentifier node = ASTFactory.identifier5("a", "b");
     node.identifier.element = variable;
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
     _listener.assertNoErrors();
   }
@@ skipping 33 matching lines @@
   }
   void test_visitPrefixExpression_tilde() {
     PrefixExpression node = ASTFactory.prefixExpression(TokenType.TILDE, resolvedInteger(0));
     MethodElement tildeMethod = getMethod(_typeProvider.intType, "~");
     node.staticElement = tildeMethod;
     node.element = tildeMethod;
     JUnitTestCase.assertSame(_typeProvider.intType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitPropertyAccess_getter() {
-    Type2 boolType2 = _typeProvider.boolType;
-    PropertyAccessorElementImpl getter = ElementFactory.getterElement("b", false, boolType2);
+    Type2 boolType = _typeProvider.boolType;
+    PropertyAccessorElementImpl getter = ElementFactory.getterElement("b", false, boolType);
     PropertyAccess node = ASTFactory.propertyAccess2(ASTFactory.identifier3("a"), "b");
     node.propertyName.element = getter;
-    JUnitTestCase.assertSame(boolType2, analyze(node));
+    JUnitTestCase.assertSame(boolType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitPropertyAccess_setter() {
-    Type2 boolType2 = _typeProvider.boolType;
-    FieldElementImpl field = ElementFactory.fieldElement("b", false, false, false, boolType2);
-    PropertyAccessorElement setter2 = field.setter;
+    Type2 boolType = _typeProvider.boolType;
+    FieldElementImpl field = ElementFactory.fieldElement("b", false, false, false, boolType);
+    PropertyAccessorElement setter = field.setter;
     PropertyAccess node = ASTFactory.propertyAccess2(ASTFactory.identifier3("a"), "b");
-    node.propertyName.element = setter2;
-    JUnitTestCase.assertSame(boolType2, analyze(node));
+    node.propertyName.element = setter;
+    JUnitTestCase.assertSame(boolType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitSimpleStringLiteral() {
     Expression node = resolvedString("a");
     JUnitTestCase.assertSame(_typeProvider.stringType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitStringInterpolation() {
     Expression node = ASTFactory.string([ASTFactory.interpolationString("a", "a"), ASTFactory.interpolationExpression(resolvedString("b")), ASTFactory.interpolationString("c", "c")]);
     JUnitTestCase.assertSame(_typeProvider.stringType, analyze(node));
@@ skipping 98 matching lines @@
       for (MapEntry<String, Type2> entry in getMapEntrySet(expectedNamedTypes)) {
         JUnitTestCase.assertSame(entry.getValue(), namedTypes[entry.getKey()]);
       }
     }
     JUnitTestCase.assertSame(expectedReturnType, functionType.returnType);
   }
   void assertType(InterfaceTypeImpl expectedType, InterfaceTypeImpl actualType) {
     JUnitTestCase.assertEquals(expectedType.displayName, actualType.displayName);
     JUnitTestCase.assertEquals(expectedType.element, actualType.element);
     List<Type2> expectedArguments = expectedType.typeArguments;
-    int length2 = expectedArguments.length;
+    int length = expectedArguments.length;
     List<Type2> actualArguments = actualType.typeArguments;
-    EngineTestCase.assertLength(length2, actualArguments);
-    for (int i = 0; i < length2; i++) {
+    EngineTestCase.assertLength(length, actualArguments);
+    for (int i = 0; i < length; i++) {
       assertType2(expectedArguments[i], actualArguments[i]);
     }
   }
   void assertType2(Type2 expectedType, Type2 actualType) {
     if (expectedType is InterfaceTypeImpl) {
       EngineTestCase.assertInstanceOf(InterfaceTypeImpl, actualType);
       assertType((expectedType as InterfaceTypeImpl), (actualType as InterfaceTypeImpl));
     }
   }
 
@@ skipping 98 matching lines @@
     node.staticElement = element2;
     node.element = element2;
   }
 
   /**
    * Set the type of the given parameter to the given type.
    * @param parameter the parameter whose type is to be set
    * @param type the new type of the given parameter
    */
   void setType(FormalParameter parameter, Type2 type2) {
-    SimpleIdentifier identifier2 = parameter.identifier;
-    Element element2 = identifier2.element;
-    if (element2 is! ParameterElement) {
-      element2 = new ParameterElementImpl(identifier2);
-      identifier2.element = element2;
+    SimpleIdentifier identifier = parameter.identifier;
+    Element element = identifier.element;
+    if (element is! ParameterElement) {
+      element = new ParameterElementImpl(identifier);
+      identifier.element = element;
     }
-    ((element2 as ParameterElementImpl)).type = type2;
+    ((element as ParameterElementImpl)).type = type2;
   }
   static dartSuite() {
     _ut.group('StaticTypeAnalyzerTest', () {
       _ut.test('test_visitAdjacentStrings', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitAdjacentStrings);
       });
       _ut.test('test_visitArgumentDefinitionTest', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitArgumentDefinitionTest);
@@ skipping 403 matching lines @@
     return source;
   }
 
   /**
    * Ensure that there are elements representing all of the types in the given array of type names.
    * @param unit the compilation unit containing the types
    * @param typeNames the names of the types that should be found
    */
   void assertTypes(CompilationUnitElement unit, List<String> typeNames) {
     JUnitTestCase.assertNotNull(unit);
-    List<ClassElement> types2 = unit.types;
-    EngineTestCase.assertLength(typeNames.length, types2);
-    for (ClassElement type in types2) {
+    List<ClassElement> types = unit.types;
+    EngineTestCase.assertLength(typeNames.length, types);
+    for (ClassElement type in types) {
       JUnitTestCase.assertNotNull(type);
       String actualTypeName = type.displayName;
       bool wasExpected = false;
       for (String expectedTypeName in typeNames) {
         if (expectedTypeName == actualTypeName) {
           wasExpected = true;
         }
       }
       if (!wasExpected) {
         JUnitTestCase.fail("Found unexpected type ${actualTypeName}");
@@ skipping 475 matching lines @@
    * error can be denoted by including a negative index in the array of indices.
    * @param source the source to be resolved
    * @param indices the array of indices used to associate arguments with parameters
    * @throws Exception if the source could not be resolved or if the structure of the source is not
    * valid
    */
   void validateArgumentResolution(Source source, List<int> indices) {
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     ClassElement classElement = library.definingCompilationUnit.types[0];
-    List<ParameterElement> parameters2 = classElement.methods[1].parameters;
+    List<ParameterElement> parameters = classElement.methods[1].parameters;
     CompilationUnit unit = resolveCompilationUnit(source, library);
     JUnitTestCase.assertNotNull(unit);
     ClassDeclaration classDeclaration = unit.declarations[0] as ClassDeclaration;
     MethodDeclaration methodDeclaration = (classDeclaration.members[0] as MethodDeclaration);
-    Block block2 = ((methodDeclaration.body as BlockFunctionBody)).block;
-    ExpressionStatement statement = block2.statements[0] as ExpressionStatement;
+    Block block = ((methodDeclaration.body as BlockFunctionBody)).block;
+    ExpressionStatement statement = block.statements[0] as ExpressionStatement;
     MethodInvocation invocation = statement.expression as MethodInvocation;
-    NodeList<Expression> arguments2 = invocation.argumentList.arguments;
-    int argumentCount = arguments2.length;
+    NodeList<Expression> arguments = invocation.argumentList.arguments;
+    int argumentCount = arguments.length;
     JUnitTestCase.assertEquals(indices.length, argumentCount);
     for (int i = 0; i < argumentCount; i++) {
-      Expression argument = arguments2[i];
+      Expression argument = arguments[i];
       ParameterElement element = argument.staticParameterElement;
       int index = indices[i];
       if (index < 0) {
         JUnitTestCase.assertNull(element);
       } else {
-        JUnitTestCase.assertSame(parameters2[index], element);
+        JUnitTestCase.assertSame(parameters[index], element);
       }
     }
   }
   static dartSuite() {
     _ut.group('SimpleResolverTest', () {
       _ut.test('test_argumentResolution_requiredAndNamed_extra', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_argumentResolution_requiredAndNamed_extra);
       });
       _ut.test('test_argumentResolution_requiredAndNamed_matching', () {
@@ skipping 165 matching lines @@
         runJUnitTest(__test, __test.test_setter_inherited);
       });
       _ut.test('test_setter_static', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_setter_static);
       });
     });
   }
 }
 main() {
-//  ElementResolverTest.dartSuite();
-//  InheritanceManagerTest.dartSuite();
-//  LibraryElementBuilderTest.dartSuite();
-//  LibraryTest.dartSuite();
-//  StaticTypeAnalyzerTest.dartSuite();
-//  TypeOverrideManagerTest.dartSuite();
-//  TypeProviderImplTest.dartSuite();
-//  TypeResolverVisitorTest.dartSuite();
-//  EnclosedScopeTest.dartSuite();
-//  LibraryImportScopeTest.dartSuite();
-//  LibraryScopeTest.dartSuite();
-//  ScopeTest.dartSuite();
-//  CompileTimeErrorCodeTest.dartSuite();
-//  ErrorResolverTest.dartSuite();
-//  NonErrorResolverTest.dartSuite();
-//  PubSuggestionCodeTest.dartSuite();
-//  SimpleResolverTest.dartSuite();
-//  StaticTypeWarningCodeTest.dartSuite();
-//  StaticWarningCodeTest.dartSuite();
-//  StrictModeTest.dartSuite();
-//  TypePropagationTest.dartSuite();
+  ElementResolverTest.dartSuite();
+  InheritanceManagerTest.dartSuite();
+  LibraryElementBuilderTest.dartSuite();
+  LibraryTest.dartSuite();
+  StaticTypeAnalyzerTest.dartSuite();
+  TypeOverrideManagerTest.dartSuite();
+  TypeProviderImplTest.dartSuite();
+  TypeResolverVisitorTest.dartSuite();
+  EnclosedScopeTest.dartSuite();
+  LibraryImportScopeTest.dartSuite();
+  LibraryScopeTest.dartSuite();
+  ScopeTest.dartSuite();
+  CompileTimeErrorCodeTest.dartSuite();
+  ErrorResolverTest.dartSuite();
+  NonErrorResolverTest.dartSuite();
+  PubSuggestionCodeTest.dartSuite();
+  SimpleResolverTest.dartSuite();
+  StaticTypeWarningCodeTest.dartSuite();
+  StaticWarningCodeTest.dartSuite();
+  StrictModeTest.dartSuite();
+  TypePropagationTest.dartSuite();
 }