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

pkg/analyzer_experimental/lib/src/generated/resolver.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;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'instrumentation.dart';
 import 'source.dart';
 import 'error.dart';
 import 'scanner.dart' as sc;
@@ skipping 76 matching lines @@
     bool wasInField = _inFieldContext;
     _inFieldContext = false;
     try {
       node.visitChildren(this);
     } finally {
       _inFieldContext = wasInField;
     }
     return null;
   }
   Object visitCatchClause(CatchClause node) {
-    SimpleIdentifier exceptionParameter2 = node.exceptionParameter;
-    if (exceptionParameter2 != null) {
-      LocalVariableElementImpl exception = new LocalVariableElementImpl(exceptionParameter2);
+    SimpleIdentifier exceptionParameter = node.exceptionParameter;
+    if (exceptionParameter != null) {
+      LocalVariableElementImpl exception = new LocalVariableElementImpl(exceptionParameter);
       _currentHolder.addLocalVariable(exception);
-      exceptionParameter2.element = exception;
-      SimpleIdentifier stackTraceParameter2 = node.stackTraceParameter;
-      if (stackTraceParameter2 != null) {
-        LocalVariableElementImpl stackTrace = new LocalVariableElementImpl(stackTraceParameter2);
+      exceptionParameter.element = exception;
+      SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
+      if (stackTraceParameter != null) {
+        LocalVariableElementImpl stackTrace = new LocalVariableElementImpl(stackTraceParameter);
         _currentHolder.addLocalVariable(stackTrace);
-        stackTraceParameter2.element = stackTrace;
+        stackTraceParameter.element = stackTrace;
       }
     }
     return super.visitCatchClause(node);
   }
   Object visitClassDeclaration(ClassDeclaration node) {
     ElementHolder holder = new ElementHolder();
     _isValidMixin = true;
     visitChildren(holder, node);
     SimpleIdentifier className = node.name;
     ClassElementImpl element = new ClassElementImpl(className);
-    List<TypeVariableElement> typeVariables2 = holder.typeVariables;
+    List<TypeVariableElement> typeVariables = holder.typeVariables;
     InterfaceTypeImpl interfaceType = new InterfaceTypeImpl.con1(element);
-    interfaceType.typeArguments = createTypeVariableTypes(typeVariables2);
+    interfaceType.typeArguments = createTypeVariableTypes(typeVariables);
     element.type = interfaceType;
-    List<ConstructorElement> constructors2 = holder.constructors;
-    if (constructors2.length == 0) {
-      constructors2 = createDefaultConstructors(interfaceType);
+    List<ConstructorElement> constructors = holder.constructors;
+    if (constructors.length == 0) {
+      constructors = createDefaultConstructors(interfaceType);
     }
     element.abstract = node.abstractKeyword != null;
     element.accessors = holder.accessors;
-    element.constructors = constructors2;
+    element.constructors = constructors;
     element.fields = holder.fields;
     element.methods = holder.methods;
-    element.typeVariables = typeVariables2;
+    element.typeVariables = typeVariables;
     element.validMixin = _isValidMixin;
     _currentHolder.addType(element);
     className.element = element;
     return null;
   }
   Object visitClassTypeAlias(ClassTypeAlias node) {
     ElementHolder holder = new ElementHolder();
     visitChildren(holder, node);
     SimpleIdentifier className = node.name;
     ClassElementImpl element = new ClassElementImpl(className);
     element.abstract = node.abstractKeyword != null;
     element.typedef = true;
-    List<TypeVariableElement> typeVariables2 = holder.typeVariables;
-    element.typeVariables = typeVariables2;
+    List<TypeVariableElement> typeVariables = holder.typeVariables;
+    element.typeVariables = typeVariables;
     InterfaceTypeImpl interfaceType = new InterfaceTypeImpl.con1(element);
-    interfaceType.typeArguments = createTypeVariableTypes(typeVariables2);
+    interfaceType.typeArguments = createTypeVariableTypes(typeVariables);
     element.type = interfaceType;
     element.constructors = createDefaultConstructors(interfaceType);
     _currentHolder.addType(element);
     className.element = element;
     return null;
   }
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     _isValidMixin = false;
     ElementHolder holder = new ElementHolder();
     bool wasInFunction = _inFunction;
     _inFunction = true;
     try {
       visitChildren(holder, node);
     } finally {
       _inFunction = wasInFunction;
     }
     SimpleIdentifier constructorName = node.name;
     ConstructorElementImpl element = new ConstructorElementImpl(constructorName);
     if (node.factoryKeyword != null) {
       element.factory = true;
     }
     element.functions = holder.functions;
     element.labels = holder.labels;
     element.localVariables = holder.localVariables;
     element.parameters = holder.parameters;
     element.const2 = node.constKeyword != null;
     _currentHolder.addConstructor(element);
     node.element = element;
     if (constructorName == null) {
-      Identifier returnType2 = node.returnType;
-      if (returnType2 != null) {
-        element.nameOffset = returnType2.offset;
+      Identifier returnType = node.returnType;
+      if (returnType != null) {
+        element.nameOffset = returnType.offset;
       }
     } else {
       constructorName.element = element;
     }
     return null;
   }
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     SimpleIdentifier variableName = node.identifier;
-    sc.Token keyword2 = node.keyword;
+    sc.Token keyword = node.keyword;
     LocalVariableElementImpl element = new LocalVariableElementImpl(variableName);
     ForEachStatement statement = node.parent as ForEachStatement;
     int declarationEnd = node.offset + node.length;
     int statementEnd = statement.offset + statement.length;
     element.setVisibleRange(declarationEnd, statementEnd - declarationEnd - 1);
-    element.const3 = matches(keyword2, sc.Keyword.CONST);
-    element.final2 = matches(keyword2, sc.Keyword.FINAL);
+    element.const3 = matches(keyword, sc.Keyword.CONST);
+    element.final2 = matches(keyword, sc.Keyword.FINAL);
     _currentHolder.addLocalVariable(element);
     variableName.element = element;
     return super.visitDeclaredIdentifier(node);
   }
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     ElementHolder holder = new ElementHolder();
     visit(holder, node.defaultValue);
     FunctionElementImpl initializer = new FunctionElementImpl();
     initializer.functions = holder.functions;
     initializer.labels = holder.labels;
@@ skipping 134 matching lines @@
     FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
     element.type = type;
     _currentHolder.addFunction(element);
     node.element = element;
     return null;
   }
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     ElementHolder holder = new ElementHolder();
     visitChildren(holder, node);
     SimpleIdentifier aliasName = node.name;
-    List<ParameterElement> parameters2 = holder.parameters;
-    List<TypeVariableElement> typeVariables2 = holder.typeVariables;
+    List<ParameterElement> parameters = holder.parameters;
+    List<TypeVariableElement> typeVariables = holder.typeVariables;
     FunctionTypeAliasElementImpl element = new FunctionTypeAliasElementImpl(aliasName);
-    element.parameters = parameters2;
-    element.typeVariables = typeVariables2;
+    element.parameters = parameters;
+    element.typeVariables = typeVariables;
     FunctionTypeImpl type = new FunctionTypeImpl.con2(element);
-    type.typeArguments = createTypeVariableTypes(typeVariables2);
+    type.typeArguments = createTypeVariableTypes(typeVariables);
     element.type = type;
     _currentHolder.addTypeAlias(element);
     aliasName.element = element;
     return null;
   }
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElementImpl parameter = new ParameterElementImpl(parameterName);
       parameter.parameterKind = node.kind;
@@ skipping 17 matching lines @@
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
     ElementHolder holder = new ElementHolder();
     bool wasInFunction = _inFunction;
     _inFunction = true;
     try {
       visitChildren(holder, node);
     } finally {
       _inFunction = wasInFunction;
     }
-    bool isStatic2 = node.isStatic();
+    bool isStatic = node.isStatic();
     sc.Token property = node.propertyKeyword;
     if (property == null) {
       SimpleIdentifier methodName = node.name;
       String nameOfMethod = methodName.name;
       if (nameOfMethod == sc.TokenType.MINUS.lexeme && node.parameters.parameters.length == 0) {
         nameOfMethod = "unary-";
       }
       MethodElementImpl element = new MethodElementImpl.con2(nameOfMethod, methodName.offset);
       element.abstract = node.isAbstract();
       element.functions = holder.functions;
       element.labels = holder.labels;
       element.localVariables = holder.localVariables;
       element.parameters = holder.parameters;
-      element.static = isStatic2;
+      element.static = isStatic;
       _currentHolder.addMethod(element);
       methodName.element = element;
     } else {
       SimpleIdentifier propertyNameNode = node.name;
       String propertyName = propertyNameNode.name;
       FieldElementImpl field = _currentHolder.getField(propertyName) as FieldElementImpl;
       if (field == null) {
         field = new FieldElementImpl.con2(node.name.name);
         field.final2 = true;
-        field.static = isStatic2;
+        field.static = isStatic;
         _currentHolder.addField(field);
       }
       if (matches(property, sc.Keyword.GET)) {
         PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl.con1(propertyNameNode);
         getter.functions = holder.functions;
         getter.labels = holder.labels;
         getter.localVariables = holder.localVariables;
         getter.variable = field;
         getter.abstract = node.body is EmptyFunctionBody && node.externalKeyword == null;
         getter.getter = true;
-        getter.static = isStatic2;
+        getter.static = isStatic;
         field.getter = getter;
         _currentHolder.addAccessor(getter);
         propertyNameNode.element = getter;
       } else {
         PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl.con1(propertyNameNode);
         setter.functions = holder.functions;
         setter.labels = holder.labels;
         setter.localVariables = holder.localVariables;
         setter.parameters = holder.parameters;
         setter.variable = field;
         setter.abstract = node.body is EmptyFunctionBody && !matches(node.externalKeyword, sc.Keyword.EXTERNAL);
         setter.setter = true;
-        setter.static = isStatic2;
+        setter.static = isStatic;
         field.setter = setter;
         field.final2 = false;
         _currentHolder.addAccessor(setter);
         propertyNameNode.element = setter;
       }
     }
     return null;
   }
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
@@ skipping 32 matching lines @@
   Object visitTypeParameter(TypeParameter node) {
     SimpleIdentifier parameterName = node.name;
     TypeVariableElementImpl element = new TypeVariableElementImpl(parameterName);
     TypeVariableTypeImpl type = new TypeVariableTypeImpl(element);
     element.type = type;
     _currentHolder.addTypeVariable(element);
     parameterName.element = element;
     return super.visitTypeParameter(node);
   }
   Object visitVariableDeclaration(VariableDeclaration node) {
-    sc.Token keyword2 = ((node.parent as VariableDeclarationList)).keyword;
-    bool isConst = matches(keyword2, sc.Keyword.CONST);
-    bool isFinal = matches(keyword2, sc.Keyword.FINAL);
+    sc.Token keyword = ((node.parent as VariableDeclarationList)).keyword;
+    bool isConst = matches(keyword, sc.Keyword.CONST);
+    bool isFinal = matches(keyword, sc.Keyword.FINAL);
     bool hasInitializer = node.initializer != null;
     VariableElementImpl element;
     if (_inFieldContext) {
       SimpleIdentifier fieldName = node.name;
       FieldElementImpl field;
       if (isConst && hasInitializer) {
         field = new ConstFieldElementImpl(fieldName);
       } else {
         field = new FieldElementImpl.con1(fieldName);
       }
@@ skipping 91 matching lines @@
     return typeArguments;
   }
 
   /**
    * Return the body of the function that contains the given parameter, or {@code null} if no
    * function body could be found.
    * @param node the parameter contained in the function whose body is to be returned
    * @return the body of the function that contains the given parameter
    */
   FunctionBody getFunctionBody(FormalParameter node) {
-    ASTNode parent2 = node.parent;
-    while (parent2 != null) {
-      if (parent2 is FunctionExpression) {
-        return ((parent2 as FunctionExpression)).body;
-      } else if (parent2 is MethodDeclaration) {
-        return ((parent2 as MethodDeclaration)).body;
+    ASTNode parent = node.parent;
+    while (parent != null) {
+      if (parent is FunctionExpression) {
+        return ((parent as FunctionExpression)).body;
+      } else if (parent is MethodDeclaration) {
+        return ((parent as MethodDeclaration)).body;
       }
-      parent2 = parent2.parent;
+      parent = parent.parent;
     }
     return null;
   }
 
   /**
    * Return {@code true} if the given token is a token for the given keyword.
    * @param token the token being tested
    * @param keyword the keyword being tested for
    * @return {@code true} if the given token is a token for the given keyword
    */
@@ skipping 296 matching lines @@
     }
     _parentNodes.add(node);
     try {
       if (isScriptNode(node)) {
         Source htmlSource = _htmlElement.source;
         ht.XmlAttributeNode scriptAttribute = getScriptSourcePath(node);
         String scriptSourcePath = scriptAttribute == null ? null : scriptAttribute.text;
         if (identical(node.attributeEnd.type, ht.TokenType.GT) && scriptSourcePath == null) {
           EmbeddedHtmlScriptElementImpl script = new EmbeddedHtmlScriptElementImpl(node);
           String contents = node.content;
-          int attributeEnd2 = node.attributeEnd.end;
-          LineInfo_Location location = _lineInfo.getLocation(attributeEnd2);
+          int attributeEnd = node.attributeEnd.end;
+          LineInfo_Location location = _lineInfo.getLocation(attributeEnd);
           sc.StringScanner scanner = new sc.StringScanner(htmlSource, contents, _errorListener);
-          scanner.setSourceStart(location.lineNumber, location.columnNumber, attributeEnd2);
+          scanner.setSourceStart(location.lineNumber, location.columnNumber, attributeEnd);
           sc.Token firstToken = scanner.tokenize();
-          List<int> lineStarts2 = scanner.lineStarts;
+          List<int> lineStarts = scanner.lineStarts;
           Parser parser = new Parser(htmlSource, _errorListener);
           CompilationUnit unit = parser.parseCompilationUnit(firstToken);
-          unit.lineInfo = new LineInfo(lineStarts2);
+          unit.lineInfo = new LineInfo(lineStarts);
           try {
             LibraryResolver resolver = new LibraryResolver(_context);
             LibraryElementImpl library = resolver.resolveEmbeddedLibrary(htmlSource, unit, true) as LibraryElementImpl;
             script.scriptLibrary = library;
             _resolvedLibraries.addAll(resolver.resolvedLibraries);
             _errorListener.addAll(resolver.errorListener);
           } on AnalysisException catch (exception) {
             AnalysisEngine.instance.logger.logError3(exception);
           }
           _scripts.add(script);
@@ skipping 111 matching lines @@
    * element.
    * @param unit the compilation unit to be resolved
    * @param element the root of the element model used to resolve the AST nodes
    */
   void resolve(CompilationUnit unit, CompilationUnitElement element2) {
     _enclosingUnit = element2;
     unit.element = element2;
     unit.accept(this);
   }
   Object visitCatchClause(CatchClause node) {
-    SimpleIdentifier exceptionParameter2 = node.exceptionParameter;
-    if (exceptionParameter2 != null) {
-      List<LocalVariableElement> localVariables2 = _enclosingExecutable.localVariables;
-      find3(localVariables2, exceptionParameter2);
-      SimpleIdentifier stackTraceParameter2 = node.stackTraceParameter;
-      if (stackTraceParameter2 != null) {
-        find3(localVariables2, stackTraceParameter2);
+    SimpleIdentifier exceptionParameter = node.exceptionParameter;
+    if (exceptionParameter != null) {
+      List<LocalVariableElement> localVariables = _enclosingExecutable.localVariables;
+      find3(localVariables, exceptionParameter);
+      SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
+      if (stackTraceParameter != null) {
+        find3(localVariables, stackTraceParameter);
       }
     }
     return super.visitCatchClause(node);
   }
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement outerClass = _enclosingClass;
     try {
       SimpleIdentifier className = node.name;
       _enclosingClass = find3(_enclosingUnit.types, className);
       return super.visitClassDeclaration(node);
@@ skipping 35 matching lines @@
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     SimpleIdentifier parameterName = node.parameter.identifier;
     ParameterElement element = null;
     if (_enclosingExecutable != null) {
       element = find3(_enclosingExecutable.parameters, parameterName);
     } else {
       PrintStringWriter writer = new PrintStringWriter();
       writer.println("Invalid state found in the Analysis Engine:");
       writer.println("DeclarationResolver.visitDefaultFormalParameter() is visiting a parameter that does not appear to be in a method or function.");
       writer.println("Ancestors:");
-      ASTNode parent2 = node.parent;
-      while (parent2 != null) {
-        writer.println(parent2.runtimeType.toString());
+      ASTNode parent = node.parent;
+      while (parent != null) {
+        writer.println(parent.runtimeType.toString());
         writer.println("---------");
-        parent2 = parent2.parent;
+        parent = parent.parent;
       }
       AnalysisEngine.instance.logger.logError2(writer.toString(), new AnalysisException());
     }
-    Expression defaultValue2 = node.defaultValue;
-    if (defaultValue2 != null) {
+    Expression defaultValue = node.defaultValue;
+    if (defaultValue != null) {
       ExecutableElement outerExecutable = _enclosingExecutable;
       try {
         if (element == null) {
         } else {
           _enclosingExecutable = element.initializer;
         }
-        defaultValue2.accept(this);
+        defaultValue.accept(this);
       } finally {
         _enclosingExecutable = outerExecutable;
       }
     }
     ParameterElement outerParameter = _enclosingParameter;
     try {
       _enclosingParameter = element;
       return super.visitDefaultFormalParameter(node);
     } finally {
       _enclosingParameter = outerParameter;
     }
   }
   Object visitExportDirective(ExportDirective node) {
-    String uri2 = getStringValue(node.uri);
-    if (uri2 != null) {
-      LibraryElement library2 = _enclosingUnit.library;
-      ExportElement exportElement = find5(library2.exports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri2));
+    String uri = getStringValue(node.uri);
+    if (uri != null) {
+      LibraryElement library = _enclosingUnit.library;
+      ExportElement exportElement = find5(library.exports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri));
       node.element = exportElement;
     }
     return super.visitExportDirective(node);
   }
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElement element = find3(_enclosingExecutable.parameters, parameterName);
       ParameterElement outerParameter = _enclosingParameter;
       try {
@@ skipping 63 matching lines @@
         _enclosingParameter = element;
         return super.visitFunctionTypedFormalParameter(node);
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
       return super.visitFunctionTypedFormalParameter(node);
     }
   }
   Object visitImportDirective(ImportDirective node) {
-    String uri2 = getStringValue(node.uri);
-    if (uri2 != null) {
-      LibraryElement library2 = _enclosingUnit.library;
-      ImportElement importElement = find6(library2.imports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri2), node.prefix);
+    String uri = getStringValue(node.uri);
+    if (uri != null) {
+      LibraryElement library = _enclosingUnit.library;
+      ImportElement importElement = find6(library.imports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri), node.prefix);
       node.element = importElement;
     }
     return super.visitImportDirective(node);
   }
   Object visitLabeledStatement(LabeledStatement node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       find3(_enclosingExecutable.labels, labelName);
     }
     return super.visitLabeledStatement(node);
@@ skipping 21 matching lines @@
           methodName.element = accessor;
         }
         _enclosingExecutable = accessor;
       }
       return super.visitMethodDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
   Object visitPartDirective(PartDirective node) {
-    String uri2 = getStringValue(node.uri);
-    if (uri2 != null) {
-      Source partSource = _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri2);
+    String uri = getStringValue(node.uri);
+    if (uri != null) {
+      Source partSource = _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri);
       node.element = find(_enclosingUnit.library.parts, partSource);
     }
     return super.visitPartDirective(node);
   }
   Object visitPartOfDirective(PartOfDirective node) {
     node.element = _enclosingUnit.library;
     return super.visitPartOfDirective(node);
   }
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
@@ skipping 46 matching lines @@
     SimpleIdentifier variableName = node.name;
     if (_enclosingExecutable != null) {
       element = find3(_enclosingExecutable.localVariables, variableName);
     }
     if (element == null && _enclosingClass != null) {
       element = find3(_enclosingClass.fields, variableName);
     }
     if (element == null && _enclosingUnit != null) {
       element = find3(_enclosingUnit.topLevelVariables, variableName);
     }
-    Expression initializer2 = node.initializer;
-    if (initializer2 != null) {
+    Expression initializer = node.initializer;
+    if (initializer != null) {
       ExecutableElement outerExecutable = _enclosingExecutable;
       try {
         if (element == null) {
         } else {
           _enclosingExecutable = element.initializer;
         }
         return super.visitVariableDeclaration(node);
       } finally {
         _enclosingExecutable = outerExecutable;
       }
@@ skipping 183 matching lines @@
  * names in hide and show combinators that are not defined in the imported library (which is not an
  * error).
  * @coverage dart.engine.resolver
  */
 class ElementResolver extends SimpleASTVisitor<Object> {
 
   /**
    * @return {@code true} if the given identifier is the return type of a constructor declaration.
    */
   static bool isConstructorReturnType(SimpleIdentifier node) {
-    ASTNode parent2 = node.parent;
-    if (parent2 is ConstructorDeclaration) {
-      ConstructorDeclaration constructor = parent2 as ConstructorDeclaration;
+    ASTNode parent = node.parent;
+    if (parent is ConstructorDeclaration) {
+      ConstructorDeclaration constructor = parent as ConstructorDeclaration;
       return identical(constructor.returnType, node);
     }
     return false;
   }
 
   /**
    * @return {@code true} if the given identifier is the return type of a factory constructor
    * declaration.
    */
   static bool isFactoryConstructorReturnType(SimpleIdentifier node) {
-    ASTNode parent2 = node.parent;
-    if (parent2 is ConstructorDeclaration) {
-      ConstructorDeclaration constructor = parent2 as ConstructorDeclaration;
+    ASTNode parent = node.parent;
+    if (parent is ConstructorDeclaration) {
+      ConstructorDeclaration constructor = parent as ConstructorDeclaration;
       return identical(constructor.returnType, node) && constructor.factoryKeyword != null;
     }
     return false;
   }
 
   /**
    * Checks if the given 'super' expression is used in the valid context.
    * @param node the 'super' expression to analyze
    * @return {@code true} if the given 'super' expression is in the valid context
    */
@@ skipping 42 matching lines @@
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    * @param resolver the resolver driving this participant
    */
   ElementResolver(ResolverVisitor resolver) {
     this._resolver = resolver;
     _strictMode = resolver.definingLibrary.context.analysisOptions.strictMode;
   }
   Object visitAssignmentExpression(AssignmentExpression node) {
-    sc.Token operator2 = node.operator;
-    sc.TokenType operatorType = operator2.type;
+    sc.Token operator = node.operator;
+    sc.TokenType operatorType = operator.type;
     if (operatorType != sc.TokenType.EQ) {
       operatorType = operatorFromCompoundAssignment(operatorType);
-      Expression leftHandSide2 = node.leftHandSide;
-      if (leftHandSide2 != null) {
+      Expression leftHandSide = node.leftHandSide;
+      if (leftHandSide != null) {
         String methodName = operatorType.lexeme;
-        Type2 staticType = getStaticType(leftHandSide2);
-        MethodElement staticMethod = lookUpMethod(leftHandSide2, staticType, methodName);
+        Type2 staticType = getStaticType(leftHandSide);
+        MethodElement staticMethod = lookUpMethod(leftHandSide, staticType, methodName);
         node.staticElement = staticMethod;
-        Type2 propagatedType = getPropagatedType(leftHandSide2);
-        MethodElement propagatedMethod = lookUpMethod(leftHandSide2, propagatedType, methodName);
+        Type2 propagatedType = getPropagatedType(leftHandSide);
+        MethodElement propagatedMethod = lookUpMethod(leftHandSide, propagatedType, methodName);
         node.element = select3(staticMethod, propagatedMethod);
         if (shouldReportMissingMember(staticType, staticMethod) && (_strictMode || propagatedType == null || shouldReportMissingMember(propagatedType, propagatedMethod))) {
-          _resolver.reportError6(StaticTypeWarningCode.UNDEFINED_METHOD, operator2, [methodName, staticType.displayName]);
+          _resolver.reportError6(StaticTypeWarningCode.UNDEFINED_METHOD, operator, [methodName, staticType.displayName]);
         }
       }
     }
     return null;
   }
   Object visitBinaryExpression(BinaryExpression node) {
-    sc.Token operator2 = node.operator;
-    if (operator2.isUserDefinableOperator()) {
-      Expression leftOperand2 = node.leftOperand;
-      if (leftOperand2 != null) {
-        String methodName = operator2.lexeme;
-        Type2 staticType = getStaticType(leftOperand2);
-        MethodElement staticMethod = lookUpMethod(leftOperand2, staticType, methodName);
+    sc.Token operator = node.operator;
+    if (operator.isUserDefinableOperator()) {
+      Expression leftOperand = node.leftOperand;
+      if (leftOperand != null) {
+        String methodName = operator.lexeme;
+        Type2 staticType = getStaticType(leftOperand);
+        MethodElement staticMethod = lookUpMethod(leftOperand, staticType, methodName);
         node.staticElement = staticMethod;
-        Type2 propagatedType = getPropagatedType(leftOperand2);
-        MethodElement propagatedMethod = lookUpMethod(leftOperand2, propagatedType, methodName);
+        Type2 propagatedType = getPropagatedType(leftOperand);
+        MethodElement propagatedMethod = lookUpMethod(leftOperand, propagatedType, methodName);
         node.element = select3(staticMethod, propagatedMethod);
         if (shouldReportMissingMember(staticType, staticMethod) && (_strictMode || propagatedType == null || shouldReportMissingMember(propagatedType, propagatedMethod))) {
-          _resolver.reportError6(StaticTypeWarningCode.UNDEFINED_OPERATOR, operator2, [methodName, staticType.displayName]);
+          _resolver.reportError6(StaticTypeWarningCode.UNDEFINED_OPERATOR, operator, [methodName, staticType.displayName]);
         }
       }
     }
     return null;
   }
   Object visitBreakStatement(BreakStatement node) {
     SimpleIdentifier labelNode = node.label;
     LabelElementImpl labelElement = lookupLabel(node, labelNode);
     if (labelElement != null && labelElement.isOnSwitchMember()) {
       _resolver.reportError(ResolverErrorCode.BREAK_LABEL_ON_SWITCH_MEMBER, labelNode, []);
     }
     return null;
   }
   Object visitClassDeclaration(ClassDeclaration node) {
     setMetadata(node.element, node);
     return null;
   }
   Object visitClassTypeAlias(ClassTypeAlias node) {
     setMetadata(node.element, node);
     return null;
   }
   Object visitCommentReference(CommentReference node) {
-    Identifier identifier2 = node.identifier;
-    if (identifier2 is SimpleIdentifier) {
-      SimpleIdentifier simpleIdentifier = identifier2 as SimpleIdentifier;
+    Identifier identifier = node.identifier;
+    if (identifier is SimpleIdentifier) {
+      SimpleIdentifier simpleIdentifier = identifier as SimpleIdentifier;
       Element element = resolveSimpleIdentifier(simpleIdentifier);
       if (element == null) {
         element = findImportWithoutPrefix(simpleIdentifier);
         if (element is MultiplyDefinedElement) {
           element = null;
         }
       }
       if (element == null) {
       } else {
         if (element.library != _resolver.definingLibrary) {
         }
         recordResolution(simpleIdentifier, element);
         if (node.newKeyword != null) {
           if (element is ClassElement) {
             ConstructorElement constructor = ((element as ClassElement)).unnamedConstructor;
             if (constructor == null) {
             } else {
               recordResolution(simpleIdentifier, constructor);
             }
           } else {
           }
         }
       }
-    } else if (identifier2 is PrefixedIdentifier) {
-      PrefixedIdentifier prefixedIdentifier = identifier2 as PrefixedIdentifier;
-      SimpleIdentifier prefix2 = prefixedIdentifier.prefix;
+    } else if (identifier is PrefixedIdentifier) {
+      PrefixedIdentifier prefixedIdentifier = identifier as PrefixedIdentifier;
+      SimpleIdentifier prefix = prefixedIdentifier.prefix;
       SimpleIdentifier name = prefixedIdentifier.identifier;
-      Element element = resolveSimpleIdentifier(prefix2);
+      Element element = resolveSimpleIdentifier(prefix);
       if (element == null) {
       } else {
         if (element is PrefixElement) {
-          recordResolution(prefix2, element);
-          element = _resolver.nameScope.lookup(identifier2, _resolver.definingLibrary);
+          recordResolution(prefix, element);
+          element = _resolver.nameScope.lookup(identifier, _resolver.definingLibrary);
           recordResolution(name, element);
           return null;
         }
-        LibraryElement library2 = element.library;
-        if (library2 == null) {
+        LibraryElement library = element.library;
+        if (library == null) {
           AnalysisEngine.instance.logger.logError("Found element with null library: ${element.name}");
-        } else if (library2 != _resolver.definingLibrary) {
+        } else if (library != _resolver.definingLibrary) {
         }
         recordResolution(name, element);
         if (node.newKeyword == null) {
           if (element is ClassElement) {
             Element memberElement = lookupGetterOrMethod(((element as ClassElement)).type, name.name);
             if (memberElement == null) {
               memberElement = ((element as ClassElement)).getNamedConstructor(name.name);
               if (memberElement == null) {
-                memberElement = lookUpSetter(prefix2, ((element as ClassElement)).type, name.name);
+                memberElement = lookUpSetter(prefix, ((element as ClassElement)).type, name.name);
               }
             }
             if (memberElement == null) {
             } else {
               recordResolution(name, memberElement);
             }
           } else {
           }
         } else {
           if (element is ClassElement) {
             ConstructorElement constructor = ((element as ClassElement)).getNamedConstructor(name.name);
             if (constructor == null) {
             } else {
               recordResolution(name, constructor);
             }
           } else {
           }
         }
       }
     }
     return null;
   }
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     super.visitConstructorDeclaration(node);
-    ConstructorElement element2 = node.element;
-    if (element2 is ConstructorElementImpl) {
-      ConstructorElementImpl constructorElement = element2 as ConstructorElementImpl;
+    ConstructorElement element = node.element;
+    if (element is ConstructorElementImpl) {
+      ConstructorElementImpl constructorElement = element as ConstructorElementImpl;
       ConstructorName redirectedNode = node.redirectedConstructor;
       if (redirectedNode != null) {
         ConstructorElement redirectedElement = redirectedNode.element;
         constructorElement.redirectedConstructor = redirectedElement;
       }
       for (ConstructorInitializer initializer in node.initializers) {
         if (initializer is RedirectingConstructorInvocation) {
           ConstructorElement redirectedElement = ((initializer as RedirectingConstructorInvocation)).element;
           constructorElement.redirectedConstructor = redirectedElement;
         }
       }
       setMetadata(constructorElement, node);
     }
     return null;
   }
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
-    SimpleIdentifier fieldName2 = node.fieldName;
-    ClassElement enclosingClass2 = _resolver.enclosingClass;
-    FieldElement fieldElement = ((enclosingClass2 as ClassElementImpl)).getField(fieldName2.name);
-    recordResolution(fieldName2, fieldElement);
+    SimpleIdentifier fieldName = node.fieldName;
+    ClassElement enclosingClass = _resolver.enclosingClass;
+    FieldElement fieldElement = ((enclosingClass as ClassElementImpl)).getField(fieldName.name);
+    recordResolution(fieldName, fieldElement);
     if (fieldElement == null || fieldElement.isSynthetic()) {
-      _resolver.reportError(CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTANT_FIELD, node, [fieldName2]);
+      _resolver.reportError(CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
     } else if (fieldElement.isStatic()) {
-      _resolver.reportError(CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD, node, [fieldName2]);
+      _resolver.reportError(CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD, node, [fieldName]);
     }
     return null;
   }
   Object visitConstructorName(ConstructorName node) {
-    Type2 type2 = node.type.type;
-    if (type2 != null && type2.isDynamic()) {
+    Type2 type = node.type.type;
+    if (type != null && type.isDynamic()) {
       return null;
-    } else if (type2 is! InterfaceType) {
-      ASTNode parent2 = node.parent;
-      if (parent2 is InstanceCreationExpression) {
-        if (((parent2 as InstanceCreationExpression)).isConst()) {
+    } else if (type is! InterfaceType) {
+      ASTNode parent = node.parent;
+      if (parent is InstanceCreationExpression) {
+        if (((parent as InstanceCreationExpression)).isConst()) {
         } else {
         }
       } else {
       }
       return null;
     }
     ConstructorElement constructor;
-    SimpleIdentifier name2 = node.name;
-    InterfaceType interfaceType = type2 as InterfaceType;
-    LibraryElement definingLibrary2 = _resolver.definingLibrary;
-    if (name2 == null) {
-      constructor = interfaceType.lookUpConstructor(null, definingLibrary2);
+    SimpleIdentifier name = node.name;
+    InterfaceType interfaceType = type as InterfaceType;
+    LibraryElement definingLibrary = _resolver.definingLibrary;
+    if (name == null) {
+      constructor = interfaceType.lookUpConstructor(null, definingLibrary);
     } else {
-      constructor = interfaceType.lookUpConstructor(name2.name, definingLibrary2);
-      name2.staticElement = constructor;
-      name2.element = constructor;
+      constructor = interfaceType.lookUpConstructor(name.name, definingLibrary);
+      name.staticElement = constructor;
+      name.element = constructor;
     }
     node.staticElement = constructor;
     node.element = constructor;
     return null;
   }
   Object visitContinueStatement(ContinueStatement node) {
     SimpleIdentifier labelNode = node.label;
     LabelElementImpl labelElement = lookupLabel(node, labelNode);
     if (labelElement != null && labelElement.isOnSwitchStatement()) {
       _resolver.reportError(ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH, labelNode, []);
     }
     return null;
   }
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     setMetadata(node.element, node);
     return null;
   }
   Object visitExportDirective(ExportDirective node) {
-    Element element2 = node.element;
-    if (element2 is ExportElement) {
-      resolveCombinators(((element2 as ExportElement)).exportedLibrary, node.combinators);
-      setMetadata(element2, node);
+    Element element = node.element;
+    if (element is ExportElement) {
+      resolveCombinators(((element as ExportElement)).exportedLibrary, node.combinators);
+      setMetadata(element, node);
     }
     return null;
   }
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     String fieldName = node.identifier.name;
     ClassElement classElement = _resolver.enclosingClass;
     if (classElement != null) {
       FieldElement fieldElement = ((classElement as ClassElementImpl)).getField(fieldName);
       if (fieldElement == null) {
         _resolver.reportError(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
@@ skipping 38 matching lines @@
     SimpleIdentifier prefixNode = node.prefix;
     if (prefixNode != null) {
       String prefixName = prefixNode.name;
       for (PrefixElement prefixElement in _resolver.definingLibrary.prefixes) {
         if (prefixElement.displayName == prefixName) {
           recordResolution(prefixNode, prefixElement);
           break;
         }
       }
     }
-    Element element2 = node.element;
-    if (element2 is ImportElement) {
-      ImportElement importElement = element2 as ImportElement;
+    Element element = node.element;
+    if (element is ImportElement) {
+      ImportElement importElement = element as ImportElement;
       LibraryElement library = importElement.importedLibrary;
       if (library != null) {
         resolveCombinators(library, node.combinators);
       }
-      setMetadata(element2, node);
+      setMetadata(element, node);
     }
     return null;
   }
   Object visitIndexExpression(IndexExpression node) {
     Expression target = node.realTarget;
     Type2 staticType = getStaticType(target);
     Type2 propagatedType = getPropagatedType(target);
     if (node.inGetterContext()) {
       String methodName = sc.TokenType.INDEX.lexeme;
       bool error = lookUpCheckIndexOperator(node, target, methodName, staticType, propagatedType);
       if (error) {
         return null;
       }
     }
     if (node.inSetterContext()) {
       String methodName = sc.TokenType.INDEX_EQ.lexeme;
       lookUpCheckIndexOperator(node, target, methodName, staticType, propagatedType);
     }
     return null;
   }
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     ConstructorElement invokedConstructor = node.constructorName.element;
     node.staticElement = invokedConstructor;
     node.element = invokedConstructor;
-    ArgumentList argumentList2 = node.argumentList;
-    List<ParameterElement> parameters = resolveArgumentsToParameters(node.isConst(), argumentList2, invokedConstructor);
+    ArgumentList argumentList = node.argumentList;
+    List<ParameterElement> parameters = resolveArgumentsToParameters(node.isConst(), argumentList, invokedConstructor);
     if (parameters != null) {
-      argumentList2.correspondingStaticParameters = parameters;
+      argumentList.correspondingStaticParameters = parameters;
     }
     return null;
   }
   Object visitLibraryDirective(LibraryDirective node) {
     setMetadata(node.element, node);
     return null;
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
     setMetadata(node.element, node);
     return null;
   }
   Object visitMethodInvocation(MethodInvocation node) {
-    SimpleIdentifier methodName2 = node.methodName;
+    SimpleIdentifier methodName = node.methodName;
     Expression target = node.realTarget;
     Element staticElement;
     Element propagatedElement;
     if (target is SuperExpression && !isSuperInValidContext((target as SuperExpression))) {
       return null;
     }
     if (target == null) {
-      staticElement = resolveInvokedElement2(methodName2);
+      staticElement = resolveInvokedElement2(methodName);
       propagatedElement = null;
     } else {
       Type2 targetType = getStaticType(target);
-      staticElement = resolveInvokedElement(target, targetType, methodName2);
-      propagatedElement = resolveInvokedElement(target, getPropagatedType(target), methodName2);
+      staticElement = resolveInvokedElement(target, targetType, methodName);
+      propagatedElement = resolveInvokedElement(target, getPropagatedType(target), methodName);
     }
     staticElement = convertSetterToGetter(staticElement);
     propagatedElement = convertSetterToGetter(propagatedElement);
-    recordResolution2(methodName2, staticElement, propagatedElement);
-    ArgumentList argumentList2 = node.argumentList;
+    recordResolution2(methodName, staticElement, propagatedElement);
+    ArgumentList argumentList = node.argumentList;
     if (staticElement != null) {
-      List<ParameterElement> parameters = computePropagatedParameters(argumentList2, staticElement);
+      List<ParameterElement> parameters = computePropagatedParameters(argumentList, staticElement);
       if (parameters != null) {
-        argumentList2.correspondingStaticParameters = parameters;
+        argumentList.correspondingStaticParameters = parameters;
       }
     }
     if (propagatedElement != null) {
-      List<ParameterElement> parameters = computePropagatedParameters(argumentList2, propagatedElement);
+      List<ParameterElement> parameters = computePropagatedParameters(argumentList, propagatedElement);
       if (parameters != null) {
-        argumentList2.correspondingParameters = parameters;
+        argumentList.correspondingParameters = parameters;
       }
     }
     ErrorCode errorCode;
     if (staticElement == null) {
       if (propagatedElement == null) {
         errorCode = checkForInvocationError(target, staticElement);
       } else {
         errorCode = checkForInvocationError(target, propagatedElement);
       }
     } else {
       errorCode = checkForInvocationError(target, staticElement);
       if (propagatedElement != null) {
         ErrorCode propagatedError = checkForInvocationError(target, propagatedElement);
         errorCode = select(errorCode, propagatedError);
       }
     }
     if (identical(errorCode, StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION)) {
-      _resolver.reportError(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName2, [methodName2.name]);
+      _resolver.reportError(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName, [methodName.name]);
     } else if (identical(errorCode, StaticTypeWarningCode.UNDEFINED_FUNCTION)) {
-      _resolver.reportError(StaticTypeWarningCode.UNDEFINED_FUNCTION, methodName2, [methodName2.name]);
+      _resolver.reportError(StaticTypeWarningCode.UNDEFINED_FUNCTION, methodName, [methodName.name]);
     } else if (identical(errorCode, StaticTypeWarningCode.UNDEFINED_METHOD)) {
       String targetTypeName;
       if (target == null) {
-        ClassElement enclosingClass2 = _resolver.enclosingClass;
-        targetTypeName = enclosingClass2.displayName;
+        ClassElement enclosingClass = _resolver.enclosingClass;
+        targetTypeName = enclosingClass.displayName;
       } else {
         Type2 targetType = getPropagatedType(target);
         if (targetType == null) {
           targetType = getStaticType(target);
         }
         targetTypeName = targetType == null ? null : targetType.displayName;
       }
-      _resolver.reportError(StaticTypeWarningCode.UNDEFINED_METHOD, methodName2, [methodName2.name, targetTypeName]);
+      _resolver.reportError(StaticTypeWarningCode.UNDEFINED_METHOD, methodName, [methodName.name, targetTypeName]);
     } else if (identical(errorCode, StaticTypeWarningCode.UNDEFINED_SUPER_METHOD)) {
       Type2 targetType = getPropagatedType(target);
       if (targetType == null) {
         targetType = getStaticType(target);
       }
       String targetTypeName = targetType == null ? null : targetType.name;
-      _resolver.reportError(StaticTypeWarningCode.UNDEFINED_SUPER_METHOD, methodName2, [methodName2.name, targetTypeName]);
+      _resolver.reportError(StaticTypeWarningCode.UNDEFINED_SUPER_METHOD, methodName, [methodName.name, targetTypeName]);
     }
     return null;
   }
   Object visitPartDirective(PartDirective node) {
     setMetadata(node.element, node);
     return null;
   }
   Object visitPartOfDirective(PartOfDirective node) {
     setMetadata(node.element, node);
     return null;
   }
   Object visitPostfixExpression(PostfixExpression node) {
-    Expression operand2 = node.operand;
+    Expression operand = node.operand;
     String methodName = getPostfixOperator(node);
-    Type2 staticType = getStaticType(operand2);
-    MethodElement staticMethod = lookUpMethod(operand2, staticType, methodName);
+    Type2 staticType = getStaticType(operand);
+    MethodElement staticMethod = lookUpMethod(operand, staticType, methodName);
     node.staticElement = staticMethod;
-    Type2 propagatedType = getPropagatedType(operand2);
-    MethodElement propagatedMethod = lookUpMethod(operand2, propagatedType, methodName);
+    Type2 propagatedType = getPropagatedType(operand);
+    MethodElement propagatedMethod = lookUpMethod(operand, propagatedType, methodName);
     node.element = select3(staticMethod, propagatedMethod);
     if (shouldReportMissingMember(staticType, staticMethod) && (_strictMode || propagatedType == null || shouldReportMissingMember(propagatedType, propagatedMethod))) {
       _resolver.reportError6(StaticTypeWarningCode.UNDEFINED_OPERATOR, node.operator, [methodName, staticType.displayName]);
     }
     return null;
   }
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
-    SimpleIdentifier prefix2 = node.prefix;
-    SimpleIdentifier identifier2 = node.identifier;
-    Element prefixElement = prefix2.element;
+    SimpleIdentifier prefix = node.prefix;
+    SimpleIdentifier identifier = node.identifier;
+    Element prefixElement = prefix.element;
     if (prefixElement is PrefixElement) {
       Element element = _resolver.nameScope.lookup(node, _resolver.definingLibrary);
       if (element == null) {
         return null;
       }
-      if (element is PropertyAccessorElement && identifier2.inSetterContext()) {
-        PropertyInducingElement variable2 = ((element as PropertyAccessorElement)).variable;
-        if (variable2 != null) {
-          PropertyAccessorElement setter2 = variable2.setter;
-          if (setter2 != null) {
-            element = setter2;
+      if (element is PropertyAccessorElement && identifier.inSetterContext()) {
+        PropertyInducingElement variable = ((element as PropertyAccessorElement)).variable;
+        if (variable != null) {
+          PropertyAccessorElement setter = variable.setter;
+          if (setter != null) {
+            element = setter;
           }
         }
       }
-      recordResolution(identifier2, element);
+      recordResolution(identifier, element);
       return null;
     }
-    resolvePropertyAccess(prefix2, identifier2);
+    resolvePropertyAccess(prefix, identifier);
     return null;
   }
   Object visitPrefixExpression(PrefixExpression node) {
-    sc.Token operator2 = node.operator;
-    sc.TokenType operatorType = operator2.type;
+    sc.Token operator = node.operator;
+    sc.TokenType operatorType = operator.type;
     if (operatorType.isUserDefinableOperator() || identical(operatorType, sc.TokenType.PLUS_PLUS) || identical(operatorType, sc.TokenType.MINUS_MINUS)) {
-      Expression operand2 = node.operand;
+      Expression operand = node.operand;
       String methodName = getPrefixOperator(node);
-      Type2 staticType = getStaticType(operand2);
-      MethodElement staticMethod = lookUpMethod(operand2, staticType, methodName);
+      Type2 staticType = getStaticType(operand);
+      MethodElement staticMethod = lookUpMethod(operand, staticType, methodName);
       node.staticElement = staticMethod;
-      Type2 propagatedType = getPropagatedType(operand2);
-      MethodElement propagatedMethod = lookUpMethod(operand2, propagatedType, methodName);
+      Type2 propagatedType = getPropagatedType(operand);
+      MethodElement propagatedMethod = lookUpMethod(operand, propagatedType, methodName);
       node.element = select3(staticMethod, propagatedMethod);
       if (shouldReportMissingMember(staticType, staticMethod) && (_strictMode || propagatedType == null || shouldReportMissingMember(propagatedType, propagatedMethod))) {
-        _resolver.reportError6(StaticTypeWarningCode.UNDEFINED_OPERATOR, operator2, [methodName, staticType.displayName]);
+        _resolver.reportError6(StaticTypeWarningCode.UNDEFINED_OPERATOR, operator, [methodName, staticType.displayName]);
       }
     }
     return null;
   }
   Object visitPropertyAccess(PropertyAccess node) {
     Expression target = node.realTarget;
     if (target is SuperExpression && !isSuperInValidContext((target as SuperExpression))) {
       return null;
     }
-    SimpleIdentifier propertyName2 = node.propertyName;
-    resolvePropertyAccess(target, propertyName2);
+    SimpleIdentifier propertyName = node.propertyName;
+    resolvePropertyAccess(target, propertyName);
     return null;
   }
   Object visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
-    ClassElement enclosingClass2 = _resolver.enclosingClass;
-    if (enclosingClass2 == null) {
+    ClassElement enclosingClass = _resolver.enclosingClass;
+    if (enclosingClass == null) {
       return null;
     }
     SimpleIdentifier name = node.constructorName;
     ConstructorElement element;
     if (name == null) {
-      element = enclosingClass2.unnamedConstructor;
+      element = enclosingClass.unnamedConstructor;
     } else {
-      element = enclosingClass2.getNamedConstructor(name.name);
+      element = enclosingClass.getNamedConstructor(name.name);
     }
     if (element == null) {
       return null;
     }
     if (name != null) {
       recordResolution(name, element);
     }
     node.staticElement = element;
     node.element = element;
-    ArgumentList argumentList2 = node.argumentList;
-    List<ParameterElement> parameters = resolveArgumentsToParameters(false, argumentList2, element);
+    ArgumentList argumentList = node.argumentList;
+    List<ParameterElement> parameters = resolveArgumentsToParameters(false, argumentList, element);
     if (parameters != null) {
-      argumentList2.correspondingStaticParameters = parameters;
+      argumentList.correspondingStaticParameters = parameters;
     }
     return null;
   }
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (node.element != null) {
       return null;
     }
     Element element = resolveSimpleIdentifier(node);
     if (isFactoryConstructorReturnType(node) && element != _resolver.enclosingClass) {
       _resolver.reportError(CompileTimeErrorCode.INVALID_FACTORY_NAME_NOT_A_CLASS, node, []);
     } else if (element == null) {
       if (isConstructorReturnType(node)) {
         _resolver.reportError(CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME, node, []);
       } else if (!classDeclaresNoSuchMethod(_resolver.enclosingClass)) {
         _resolver.reportError(StaticWarningCode.UNDEFINED_IDENTIFIER, node, [node.name]);
       }
     }
     recordResolution(node, element);
     return null;
   }
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
-    ClassElement enclosingClass2 = _resolver.enclosingClass;
-    if (enclosingClass2 == null) {
+    ClassElement enclosingClass = _resolver.enclosingClass;
+    if (enclosingClass == null) {
       return null;
     }
-    ClassElement superclass = getSuperclass(enclosingClass2);
+    ClassElement superclass = getSuperclass(enclosingClass);
     if (superclass == null) {
       return null;
     }
     SimpleIdentifier name = node.constructorName;
     ConstructorElement element;
     if (name == null) {
       element = superclass.unnamedConstructor;
     } else {
       element = superclass.getNamedConstructor(name.name);
     }
     if (element == null) {
       if (name != null) {
         _resolver.reportError(CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER, node, [superclass.name, name]);
       } else {
         _resolver.reportError(CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT, node, [superclass.name]);
       }
       return null;
     } else {
       if (element.isFactory()) {
         _resolver.reportError(CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node, [element]);
       }
     }
     if (name != null) {
       recordResolution(name, element);
     }
     node.staticElement = element;
     node.element = element;
-    ArgumentList argumentList2 = node.argumentList;
-    List<ParameterElement> parameters = resolveArgumentsToParameters(false, argumentList2, element);
+    ArgumentList argumentList = node.argumentList;
+    List<ParameterElement> parameters = resolveArgumentsToParameters(false, argumentList, element);
     if (parameters != null) {
-      argumentList2.correspondingStaticParameters = parameters;
+      argumentList.correspondingStaticParameters = parameters;
     }
     return null;
   }
   Object visitSuperExpression(SuperExpression node) {
     if (!isSuperInValidContext(node)) {
       _resolver.reportError(CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT, node, []);
     }
     return super.visitSuperExpression(node);
   }
   Object visitTypeParameter(TypeParameter node) {
-    TypeName bound2 = node.bound;
-    if (bound2 != null) {
+    TypeName bound = node.bound;
+    if (bound != null) {
       TypeVariableElementImpl variable = node.name.element as TypeVariableElementImpl;
       if (variable != null) {
-        variable.bound = bound2.type;
+        variable.bound = bound.type;
       }
     }
     setMetadata(node.element, node);
     return null;
   }
   Object visitVariableDeclaration(VariableDeclaration node) {
     setMetadata(node.element, node);
     return null;
   }
 
@@ skipping 16 matching lines @@
    * Given that we have found code to invoke the given element, return the error code that should be
    * reported, or {@code null} if no error should be reported.
    * @param target the target of the invocation, or {@code null} if there was no target
    * @param element the element to be invoked
    * @return the error code that should be reported
    */
   ErrorCode checkForInvocationError(Expression target, Element element2) {
     if (element2 is PropertyAccessorElement) {
       FunctionType getterType = ((element2 as PropertyAccessorElement)).type;
       if (getterType != null) {
-        Type2 returnType2 = getterType.returnType;
-        if (!isExecutableType(returnType2)) {
+        Type2 returnType = getterType.returnType;
+        if (!isExecutableType(returnType)) {
           return StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION;
         }
       }
     } else if (element2 is ExecutableElement) {
       return null;
     } else if (element2 == null && target is SuperExpression) {
       return StaticTypeWarningCode.UNDEFINED_SUPER_METHOD;
     } else {
       if (element2 is PropertyInducingElement) {
-        PropertyAccessorElement getter2 = ((element2 as PropertyInducingElement)).getter;
-        FunctionType getterType = getter2.type;
+        PropertyAccessorElement getter = ((element2 as PropertyInducingElement)).getter;
+        FunctionType getterType = getter.type;
         if (getterType != null) {
-          Type2 returnType3 = getterType.returnType;
-          if (!isExecutableType(returnType3)) {
+          Type2 returnType = getterType.returnType;
+          if (!isExecutableType(returnType)) {
             return StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION;
           }
         }
       } else if (element2 is VariableElement) {
         Type2 variableType = _resolver.overrideManager.getType(element2);
         if (variableType == null) {
           variableType = ((element2 as VariableElement)).type;
         }
         if (!isExecutableType(variableType)) {
           return StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION;
         }
       } else {
         if (target == null) {
-          ClassElement enclosingClass2 = _resolver.enclosingClass;
-          if (enclosingClass2 == null) {
+          ClassElement enclosingClass = _resolver.enclosingClass;
+          if (enclosingClass == null) {
             return StaticTypeWarningCode.UNDEFINED_FUNCTION;
           } else if (element2 == null) {
-            if (!classDeclaresNoSuchMethod(enclosingClass2)) {
+            if (!classDeclaresNoSuchMethod(enclosingClass)) {
               return StaticTypeWarningCode.UNDEFINED_METHOD;
             }
           } else {
             return StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION;
           }
         } else {
           Type2 targetType = getStaticType(target);
           if (targetType == null) {
             return StaticTypeWarningCode.UNDEFINED_FUNCTION;
           } else if (!targetType.isDynamic() && !classDeclaresNoSuchMethod2(targetType.element)) {
@@ skipping 55 matching lines @@
           Element functionElement = ((getterReturnType as FunctionType)).element;
           if (functionElement is ExecutableElement) {
             return resolveArgumentsToParameters(false, argumentList, (functionElement as ExecutableElement));
           }
         }
       }
     } else if (element2 is ExecutableElement) {
       return resolveArgumentsToParameters(false, argumentList, (element2 as ExecutableElement));
     } else if (element2 is VariableElement) {
       VariableElement variable = element2 as VariableElement;
-      Type2 type2 = variable.type;
-      if (type2 is FunctionType) {
-        FunctionType functionType = type2 as FunctionType;
-        List<ParameterElement> parameters2 = functionType.parameters;
-        return resolveArgumentsToParameters2(false, argumentList, parameters2);
-      } else if (type2 is InterfaceType) {
-        MethodElement callMethod = ((type2 as InterfaceType)).lookUpMethod(CALL_METHOD_NAME, _resolver.definingLibrary);
+      Type2 type = variable.type;
+      if (type is FunctionType) {
+        FunctionType functionType = type as FunctionType;
+        List<ParameterElement> parameters = functionType.parameters;
+        return resolveArgumentsToParameters2(false, argumentList, parameters);
+      } else if (type is InterfaceType) {
+        MethodElement callMethod = ((type as InterfaceType)).lookUpMethod(CALL_METHOD_NAME, _resolver.definingLibrary);
         if (callMethod != null) {
-          List<ParameterElement> parameters3 = callMethod.parameters;
-          return resolveArgumentsToParameters2(false, argumentList, parameters3);
+          List<ParameterElement> parameters = callMethod.parameters;
+          return resolveArgumentsToParameters2(false, argumentList, parameters);
         }
       }
     }
     return null;
   }
 
   /**
    * If the given element is a setter, return the getter associated with it. Otherwise, return the
    * element unchanged.
    * @param element the element to be normalized
    * @return a non-setter element derived from the given element
    */
   Element convertSetterToGetter(Element element) {
     if (element is PropertyAccessorElement) {
       return ((element as PropertyAccessorElement)).variable.getter;
     }
     return element;
   }
 
   /**
    * Look for any declarations of the given identifier that are imported using a prefix. Return the
    * element that was found, or {@code null} if the name is not imported using a prefix.
    * @param identifier the identifier that might have been imported using a prefix
    * @return the element that was found
    */
   Element findImportWithoutPrefix(SimpleIdentifier identifier) {
     Element element = null;
-    Scope nameScope2 = _resolver.nameScope;
-    LibraryElement definingLibrary2 = _resolver.definingLibrary;
-    for (ImportElement importElement in definingLibrary2.imports) {
+    Scope nameScope = _resolver.nameScope;
+    LibraryElement definingLibrary = _resolver.definingLibrary;
+    for (ImportElement importElement in definingLibrary.imports) {
       PrefixElement prefixElement = importElement.prefix;
       if (prefixElement != null) {
         Identifier prefixedIdentifier = new ElementResolver_SyntheticIdentifier("${prefixElement.name}.${identifier.name}");
-        Element importedElement = nameScope2.lookup(prefixedIdentifier, definingLibrary2);
+        Element importedElement = nameScope.lookup(prefixedIdentifier, definingLibrary);
         if (importedElement != null) {
           if (element == null) {
             element = importedElement;
           } else {
-            element = new MultiplyDefinedElementImpl(definingLibrary2.context, element, importedElement);
+            element = new MultiplyDefinedElementImpl(definingLibrary.context, element, importedElement);
           }
         }
       }
     }
     return element;
   }
 
   /**
    * Return the name of the method invoked by the given postfix expression.
    * @param node the postfix expression being invoked
    * @return the name of the method invoked by the expression
    */
   String getPostfixOperator(PostfixExpression node) => (identical(node.operator.type, sc.TokenType.PLUS_PLUS)) ? sc.TokenType.PLUS.lexeme : sc.TokenType.MINUS.lexeme;
 
   /**
    * Return the name of the method invoked by the given postfix expression.
    * @param node the postfix expression being invoked
    * @return the name of the method invoked by the expression
    */
   String getPrefixOperator(PrefixExpression node) {
-    sc.Token operator2 = node.operator;
-    sc.TokenType operatorType = operator2.type;
+    sc.Token operator = node.operator;
+    sc.TokenType operatorType = operator.type;
     if (identical(operatorType, sc.TokenType.PLUS_PLUS)) {
       return sc.TokenType.PLUS.lexeme;
     } else if (identical(operatorType, sc.TokenType.MINUS_MINUS)) {
       return sc.TokenType.MINUS.lexeme;
     } else if (identical(operatorType, sc.TokenType.MINUS)) {
       return "unary-";
     } else {
-      return operator2.lexeme;
+      return operator.lexeme;
     }
   }
 
   /**
    * Return the propagated type of the given expression that is to be used for type analysis.
    * @param expression the expression whose type is to be returned
    * @return the type of the given expression
    */
   Type2 getPropagatedType(Expression expression) {
-    Type2 propagatedType2 = resolveTypeVariable(expression.propagatedType);
-    if (propagatedType2 is FunctionType) {
-      propagatedType2 = _resolver.typeProvider.functionType;
+    Type2 propagatedType = resolveTypeVariable(expression.propagatedType);
+    if (propagatedType is FunctionType) {
+      propagatedType = _resolver.typeProvider.functionType;
     }
-    return propagatedType2;
+    return propagatedType;
   }
 
   /**
    * Return the static type of the given expression that is to be used for type analysis.
    * @param expression the expression whose type is to be returned
    * @return the type of the given expression
    */
   Type2 getStaticType(Expression expression) {
     if (expression is NullLiteral) {
       return _resolver.typeProvider.objectType;
     }
-    Type2 staticType2 = resolveTypeVariable(expression.staticType);
-    if (staticType2 is FunctionType) {
-      staticType2 = _resolver.typeProvider.functionType;
+    Type2 staticType = resolveTypeVariable(expression.staticType);
+    if (staticType is FunctionType) {
+      staticType = _resolver.typeProvider.functionType;
     }
-    return staticType2;
+    return staticType;
   }
 
   /**
    * Return the element representing the superclass of the given class.
    * @param targetClass the class whose superclass is to be returned
    * @return the element representing the superclass of the given class
    */
   ClassElement getSuperclass(ClassElement targetClass) {
     InterfaceType superType = targetClass.supertype;
     if (superType == null) {
@@ skipping 40 matching lines @@
    * @param methodName the name of the operator associated with the context of using of the given
    * index expression
    * @return {@code true} if and only if an error code is generated on the passed node
    */
   bool lookUpCheckIndexOperator(IndexExpression node, Expression target, String methodName, Type2 staticType, Type2 propagatedType) {
     MethodElement staticMethod = lookUpMethod(target, staticType, methodName);
     MethodElement propagatedMethod = lookUpMethod(target, propagatedType, methodName);
     node.staticElement = staticMethod;
     node.element = select3(staticMethod, propagatedMethod);
     if (shouldReportMissingMember(staticType, staticMethod) && (_strictMode || propagatedType == null || shouldReportMissingMember(propagatedType, propagatedMethod))) {
-      sc.Token leftBracket2 = node.leftBracket;
-      sc.Token rightBracket2 = node.rightBracket;
-      if (leftBracket2 == null || rightBracket2 == null) {
+      sc.Token leftBracket = node.leftBracket;
+      sc.Token rightBracket = node.rightBracket;
+      if (leftBracket == null || rightBracket == null) {
         _resolver.reportError(StaticTypeWarningCode.UNDEFINED_OPERATOR, node, [methodName, staticType.displayName]);
         return true;
       } else {
-        int offset2 = leftBracket2.offset;
-        int length = rightBracket2.offset - offset2 + 1;
-        _resolver.reportError5(StaticTypeWarningCode.UNDEFINED_OPERATOR, offset2, length, [methodName, staticType.displayName]);
+        int offset = leftBracket.offset;
+        int length = rightBracket.offset - offset + 1;
+        _resolver.reportError5(StaticTypeWarningCode.UNDEFINED_OPERATOR, offset, length, [methodName, staticType.displayName]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * Look up the getter with the given name in the given type. Return the element representing the
    * getter that was found, or {@code null} if there is no getter with the given name.
    * @param target the target of the invocation, or {@code null} if there is no target
@@ skipping 46 matching lines @@
       if (getter != null) {
         return getter;
       }
     }
     for (InterfaceType mixinType in targetType.mixins) {
       PropertyAccessorElement getter = lookUpGetterInInterfaces(mixinType, true, getterName, visitedInterfaces);
       if (getter != null) {
         return getter;
       }
     }
-    InterfaceType superclass2 = targetType.superclass;
-    if (superclass2 == null) {
+    InterfaceType superclass = targetType.superclass;
+    if (superclass == null) {
       return null;
     }
-    return lookUpGetterInInterfaces(superclass2, true, getterName, visitedInterfaces);
+    return lookUpGetterInInterfaces(superclass, true, getterName, visitedInterfaces);
   }
 
   /**
    * Look up the method or getter with the given name in the given type. Return the element
    * representing the method or getter that was found, or {@code null} if there is no method or
    * getter with the given name.
    * @param type the type in which the method or getter is defined
    * @param memberName the name of the method or getter being looked up
    * @return the element representing the method or getter that was found
    */
@@ skipping 46 matching lines @@
       if (member != null) {
         return member;
       }
     }
     for (InterfaceType mixinType in targetType.mixins) {
       ExecutableElement member = lookUpGetterOrMethodInInterfaces(mixinType, true, memberName, visitedInterfaces);
       if (member != null) {
         return member;
       }
     }
-    InterfaceType superclass2 = targetType.superclass;
-    if (superclass2 == null) {
+    InterfaceType superclass = targetType.superclass;
+    if (superclass == null) {
       return null;
     }
-    return lookUpGetterOrMethodInInterfaces(superclass2, true, memberName, visitedInterfaces);
+    return lookUpGetterOrMethodInInterfaces(superclass, true, memberName, visitedInterfaces);
   }
 
   /**
    * Find the element corresponding to the given label node in the current label scope.
    * @param parentNode the node containing the given label
    * @param labelNode the node representing the label being looked up
    * @return the element corresponding to the given label node in the current scope
    */
   LabelElementImpl lookupLabel(ASTNode parentNode, SimpleIdentifier labelNode) {
-    LabelScope labelScope2 = _resolver.labelScope;
+    LabelScope labelScope = _resolver.labelScope;
     LabelElementImpl labelElement = null;
     if (labelNode == null) {
-      if (labelScope2 == null) {
+      if (labelScope == null) {
       } else {
-        labelElement = labelScope2.lookup2(LabelScope.EMPTY_LABEL) as LabelElementImpl;
+        labelElement = labelScope.lookup2(LabelScope.EMPTY_LABEL) as LabelElementImpl;
         if (labelElement == null) {
         }
         labelElement = null;
       }
     } else {
-      if (labelScope2 == null) {
+      if (labelScope == null) {
         _resolver.reportError(CompileTimeErrorCode.LABEL_UNDEFINED, labelNode, [labelNode.name]);
       } else {
-        labelElement = labelScope2.lookup(labelNode) as LabelElementImpl;
+        labelElement = labelScope.lookup(labelNode) as LabelElementImpl;
         if (labelElement == null) {
           _resolver.reportError(CompileTimeErrorCode.LABEL_UNDEFINED, labelNode, [labelNode.name]);
         } else {
           recordResolution(labelNode, labelElement);
         }
       }
     }
     if (labelElement != null) {
       ExecutableElement labelContainer = labelElement.getAncestor(ExecutableElement);
       if (labelContainer != _resolver.enclosingFunction) {
@@ skipping 57 matching lines @@
       if (method != null) {
         return method;
       }
     }
     for (InterfaceType mixinType in targetType.mixins) {
       MethodElement method = lookUpMethodInInterfaces(mixinType, true, methodName, visitedInterfaces);
       if (method != null) {
         return method;
       }
     }
-    InterfaceType superclass2 = targetType.superclass;
-    if (superclass2 == null) {
+    InterfaceType superclass = targetType.superclass;
+    if (superclass == null) {
       return null;
     }
-    return lookUpMethodInInterfaces(superclass2, true, methodName, visitedInterfaces);
+    return lookUpMethodInInterfaces(superclass, true, methodName, visitedInterfaces);
   }
 
   /**
    * Look up the setter with the given name in the given type. Return the element representing the
    * setter that was found, or {@code null} if there is no setter with the given name.
    * @param target the target of the invocation, or {@code null} if there is no target
    * @param type the type in which the setter is defined
    * @param setterName the name of the setter being looked up
    * @return the element representing the setter that was found
    */
@@ skipping 42 matching lines @@
       if (setter != null) {
         return setter;
       }
     }
     for (InterfaceType mixinType in targetType.mixins) {
       PropertyAccessorElement setter = lookUpSetterInInterfaces(mixinType, true, setterName, visitedInterfaces);
       if (setter != null) {
         return setter;
       }
     }
-    InterfaceType superclass2 = targetType.superclass;
-    if (superclass2 == null) {
+    InterfaceType superclass = targetType.superclass;
+    if (superclass == null) {
       return null;
     }
-    return lookUpSetterInInterfaces(superclass2, true, setterName, visitedInterfaces);
+    return lookUpSetterInInterfaces(superclass, true, setterName, visitedInterfaces);
   }
 
   /**
    * Return the binary operator that is invoked by the given compound assignment operator.
    * @param operator the assignment operator being mapped
    * @return the binary operator that invoked by the given assignment operator
    */
   sc.TokenType operatorFromCompoundAssignment(sc.TokenType operator) {
     while (true) {
       if (operator == sc.TokenType.AMPERSAND_EQ) {
@@ skipping 55 matching lines @@
    * correspond to the arguments, or {@code null} if no correspondence could be computed.
    * @param reportError if {@code true} then compile-time error should be reported; if {@code false}then compile-time warning
    * @param argumentList the list of arguments being passed to the element
    * @param executableElement the element that will be invoked with the arguments
    * @return the parameters that correspond to the arguments
    */
   List<ParameterElement> resolveArgumentsToParameters(bool reportError, ArgumentList argumentList, ExecutableElement executableElement) {
     if (executableElement == null) {
       return null;
     }
-    List<ParameterElement> parameters2 = executableElement.parameters;
-    return resolveArgumentsToParameters2(reportError, argumentList, parameters2);
+    List<ParameterElement> parameters = executableElement.parameters;
+    return resolveArgumentsToParameters2(reportError, argumentList, parameters);
   }
 
   /**
    * Given a list of arguments and the parameters related to the element that will be invoked using
    * those argument, compute the list of parameters that correspond to the list of arguments. Return
    * the parameters that correspond to the arguments.
    * @param reportError if {@code true} then compile-time error should be reported; if {@code false}then compile-time warning
    * @param argumentList the list of arguments being passed to the element
    * @param parameters the of the function that will be invoked with the arguments
    * @return the parameters that correspond to the arguments
    */
   List<ParameterElement> resolveArgumentsToParameters2(bool reportError2, ArgumentList argumentList, List<ParameterElement> parameters) {
     List<ParameterElement> requiredParameters = new List<ParameterElement>();
     List<ParameterElement> positionalParameters = new List<ParameterElement>();
     Map<String, ParameterElement> namedParameters = new Map<String, ParameterElement>();
     for (ParameterElement parameter in parameters) {
       ParameterKind kind = parameter.parameterKind;
       if (identical(kind, ParameterKind.REQUIRED)) {
         requiredParameters.add(parameter);
       } else if (identical(kind, ParameterKind.POSITIONAL)) {
         positionalParameters.add(parameter);
       } else {
         namedParameters[parameter.name] = parameter;
       }
     }
     List<ParameterElement> unnamedParameters = new List<ParameterElement>.from(requiredParameters);
     unnamedParameters.addAll(positionalParameters);
     int unnamedParameterCount = unnamedParameters.length;
     int unnamedIndex = 0;
-    NodeList<Expression> arguments2 = argumentList.arguments;
-    int argumentCount = arguments2.length;
+    NodeList<Expression> arguments = argumentList.arguments;
+    int argumentCount = arguments.length;
     List<ParameterElement> resolvedParameters = new List<ParameterElement>(argumentCount);
     int positionalArgumentCount = 0;
     Set<String> usedNames = new Set<String>();
     for (int i = 0; i < argumentCount; i++) {
-      Expression argument = arguments2[i];
+      Expression argument = arguments[i];
       if (argument is NamedExpression) {
         SimpleIdentifier nameNode = ((argument as NamedExpression)).name.label;
-        String name2 = nameNode.name;
-        ParameterElement element = namedParameters[name2];
+        String name = nameNode.name;
+        ParameterElement element = namedParameters[name];
         if (element == null) {
           ErrorCode errorCode = reportError2 ? CompileTimeErrorCode.UNDEFINED_NAMED_PARAMETER : StaticWarningCode.UNDEFINED_NAMED_PARAMETER;
-          _resolver.reportError(errorCode, nameNode, [name2]);
+          _resolver.reportError(errorCode, nameNode, [name]);
         } else {
           resolvedParameters[i] = element;
           recordResolution(nameNode, element);
         }
-        if (!javaSetAdd(usedNames, name2)) {
-          _resolver.reportError(CompileTimeErrorCode.DUPLICATE_NAMED_ARGUMENT, nameNode, [name2]);
+        if (!javaSetAdd(usedNames, name)) {
+          _resolver.reportError(CompileTimeErrorCode.DUPLICATE_NAMED_ARGUMENT, nameNode, [name]);
         }
       } else {
         positionalArgumentCount++;
         if (unnamedIndex < unnamedParameterCount) {
           resolvedParameters[i] = unnamedParameters[unnamedIndex++];
         }
       }
     }
     if (positionalArgumentCount < requiredParameters.length) {
       ErrorCode errorCode = reportError2 ? CompileTimeErrorCode.NOT_ENOUGH_REQUIRED_ARGUMENTS : StaticWarningCode.NOT_ENOUGH_REQUIRED_ARGUMENTS;
@@ skipping 45 matching lines @@
     if (targetType is InterfaceType) {
       InterfaceType classType = targetType as InterfaceType;
       Element element = lookUpMethod(target, classType, methodName.name);
       if (element == null) {
         element = classType.getGetter(methodName.name);
       }
       return element;
     } else if (target is SimpleIdentifier) {
       Element targetElement = ((target as SimpleIdentifier)).element;
       if (targetElement is PrefixElement) {
-        String name2 = "${((target as SimpleIdentifier)).name}.${methodName}";
-        Identifier functionName = new ElementResolver_SyntheticIdentifier(name2);
+        String name = "${((target as SimpleIdentifier)).name}.${methodName}";
+        Identifier functionName = new ElementResolver_SyntheticIdentifier(name);
         Element element = _resolver.nameScope.lookup(functionName, _resolver.definingLibrary);
         if (element != null) {
           return element;
         }
       }
     }
     return null;
   }
 
   /**
    * Given an invocation of the form 'm(a1, ..., an)', resolve 'm' to the element being invoked. If
    * the returned element is a method, then the method will be invoked. If the returned element is a
    * getter, the getter will be invoked without arguments and the result of that invocation will
    * then be invoked with the arguments.
    * @param methodName the name of the method being invoked ('m')
    * @return the element being invoked
    */
   Element resolveInvokedElement2(SimpleIdentifier methodName) {
     Element element = _resolver.nameScope.lookup(methodName, _resolver.definingLibrary);
     if (element == null) {
-      ClassElement enclosingClass2 = _resolver.enclosingClass;
-      if (enclosingClass2 != null) {
-        InterfaceType enclosingType = enclosingClass2.type;
+      ClassElement enclosingClass = _resolver.enclosingClass;
+      if (enclosingClass != null) {
+        InterfaceType enclosingType = enclosingClass.type;
         element = lookUpMethod(null, enclosingType, methodName.name);
         if (element == null) {
           element = lookUpGetter(null, enclosingType, methodName.name);
         }
       }
     }
     return element;
   }
 
   /**
@@ skipping 52 matching lines @@
   /**
    * Resolve the given simple identifier if possible. Return the element to which it could be
    * resolved, or {@code null} if it could not be resolved. This does not record the results of the
    * resolution.
    * @param node the identifier to be resolved
    * @return the element to which the identifier could be resolved
    */
   Element resolveSimpleIdentifier(SimpleIdentifier node) {
     Element element = _resolver.nameScope.lookup(node, _resolver.definingLibrary);
     if (element is PropertyAccessorElement && node.inSetterContext()) {
-      PropertyInducingElement variable2 = ((element as PropertyAccessorElement)).variable;
-      if (variable2 != null) {
-        PropertyAccessorElement setter2 = variable2.setter;
-        if (setter2 == null) {
-          ClassElement enclosingClass2 = _resolver.enclosingClass;
-          if (enclosingClass2 != null) {
-            setter2 = lookUpSetter(null, enclosingClass2.type, node.name);
+      PropertyInducingElement variable = ((element as PropertyAccessorElement)).variable;
+      if (variable != null) {
+        PropertyAccessorElement setter = variable.setter;
+        if (setter == null) {
+          ClassElement enclosingClass = _resolver.enclosingClass;
+          if (enclosingClass != null) {
+            setter = lookUpSetter(null, enclosingClass.type, node.name);
           }
         }
-        if (setter2 != null) {
-          element = setter2;
+        if (setter != null) {
+          element = setter;
         }
       }
     } else if (element == null && node.inSetterContext()) {
       element = _resolver.nameScope.lookup(new ElementResolver_SyntheticIdentifier("${node.name}="), _resolver.definingLibrary);
     }
-    ClassElement enclosingClass3 = _resolver.enclosingClass;
-    if (element == null && enclosingClass3 != null) {
-      InterfaceType enclosingType = enclosingClass3.type;
+    ClassElement enclosingClass = _resolver.enclosingClass;
+    if (element == null && enclosingClass != null) {
+      InterfaceType enclosingType = enclosingClass.type;
       if (element == null && node.inSetterContext()) {
         element = lookUpSetter(null, enclosingType, node.name);
       }
       if (element == null && node.inGetterContext()) {
         element = lookUpGetter(null, enclosingType, node.name);
       }
       if (element == null) {
         element = lookUpMethod(null, enclosingType, node.name);
       }
     }
     return element;
   }
 
   /**
    * If the given type is a type variable, resolve it to the type that should be used when looking
    * up members. Otherwise, return the original type.
    * @param type the type that is to be resolved if it is a type variable
    * @return the type that should be used in place of the argument if it is a type variable, or the
    * original argument if it isn't a type variable
    */
   Type2 resolveTypeVariable(Type2 type) {
     if (type is TypeVariableType) {
-      Type2 bound2 = ((type as TypeVariableType)).element.bound;
-      if (bound2 == null) {
+      Type2 bound = ((type as TypeVariableType)).element.bound;
+      if (bound == null) {
         return _resolver.typeProvider.objectType;
       }
-      return bound2;
+      return bound;
     }
     return type;
   }
 
   /**
    * Given two possible error codes for the same piece of code, one computed using static type
    * information and the other using propagated type information, return the error code that should
    * be reported, or {@code null} if no error should be reported.
    * @param staticError the error code computed using static type information
    * @param propagatedError the error code computed using propagated type information
@@ skipping 242 matching lines @@
    * @return a mapping between the set of all string names of the members inherited from the passed{@link ClassElement} superclass hierarchy, and the associated {@link ExecutableElement}
    */
   Map<String, ExecutableElement> computeClassChainLookupMap(ClassElement classElt, Set<ClassElement> visitedClasses) {
     Map<String, ExecutableElement> resultMap = _classLookup[classElt];
     if (resultMap != null) {
       return resultMap;
     } else {
       resultMap = new Map<String, ExecutableElement>();
     }
     ClassElement superclassElt = null;
-    InterfaceType supertype2 = classElt.supertype;
-    if (supertype2 != null) {
-      superclassElt = supertype2.element;
+    InterfaceType supertype = classElt.supertype;
+    if (supertype != null) {
+      superclassElt = supertype.element;
     } else {
       _classLookup[classElt] = resultMap;
       return resultMap;
     }
     if (superclassElt != null) {
       if (!visitedClasses.contains(superclassElt)) {
         javaSetAdd(visitedClasses, classElt);
         resultMap = new Map<String, ExecutableElement>.from(computeClassChainLookupMap(superclassElt, visitedClasses));
       } else {
         _classLookup[superclassElt] = resultMap;
         return resultMap;
       }
       recordMapWithClassMembers(resultMap, superclassElt);
     }
-    List<InterfaceType> mixins2 = classElt.mixins;
-    for (int i = mixins2.length - 1; i >= 0; i--) {
-      ClassElement mixinElement = mixins2[i].element;
+    List<InterfaceType> mixins = classElt.mixins;
+    for (int i = mixins.length - 1; i >= 0; i--) {
+      ClassElement mixinElement = mixins[i].element;
       if (mixinElement != null) {
         recordMapWithClassMembers(resultMap, mixinElement);
       }
     }
     _classLookup[classElt] = resultMap;
     return resultMap;
   }
 
   /**
    * Compute and return the inheritance path given the context of a type and a member that is
    * overridden in the inheritance path (for which the type is in the path).
    * @param chain the inheritance path that is built up as this method calls itself recursively,
    * when this method is called an empty {@link LinkedList} should be provided
    * @param currentType the current type in the inheritance path
    * @param memberName the name of the member that is being looked up the inheritance path
    */
   void computeInheritancePath(Queue<InterfaceType> chain, InterfaceType currentType, String memberName) {
     chain.add(currentType);
     ClassElement classElt = currentType.element;
-    InterfaceType supertype2 = classElt.supertype;
-    if (supertype2 == null) {
+    InterfaceType supertype = classElt.supertype;
+    if (supertype == null) {
       return;
     }
     if (chain.length != 1) {
       if (lookupMemberInClass(classElt, memberName) != null) {
         return;
       }
     }
-    List<InterfaceType> mixins2 = classElt.mixins;
-    for (int i = mixins2.length - 1; i >= 0; i--) {
-      ClassElement mixinElement = mixins2[i].element;
+    List<InterfaceType> mixins = classElt.mixins;
+    for (int i = mixins.length - 1; i >= 0; i--) {
+      ClassElement mixinElement = mixins[i].element;
       if (mixinElement != null) {
         ExecutableElement elt = lookupMemberInClass(mixinElement, memberName);
         if (elt != null) {
-          chain.add(mixins2[i]);
+          chain.add(mixins[i]);
           return;
         }
       }
     }
-    ClassElement superclassElt = supertype2.element;
+    ClassElement superclassElt = supertype.element;
     if (lookupMember(superclassElt, memberName) != null) {
-      computeInheritancePath(chain, supertype2, memberName);
+      computeInheritancePath(chain, supertype, memberName);
       return;
     }
-    List<InterfaceType> interfaces2 = classElt.interfaces;
-    for (InterfaceType interfaceType in interfaces2) {
+    List<InterfaceType> interfaces = classElt.interfaces;
+    for (InterfaceType interfaceType in interfaces) {
       ClassElement interfaceElement = interfaceType.element;
       if (interfaceElement != null && lookupMember(interfaceElement, memberName) != null) {
         computeInheritancePath(chain, interfaceType, memberName);
         return;
       }
     }
   }
 
   /**
    * Compute and return a mapping between the set of all string names of the members inherited from
    * the passed {@link ClassElement} interface hierarchy, and the associated{@link ExecutableElement}.
    * @param classElt the class element to query
    * @param visitedInterfaces a set of visited classes passed back into this method when it calls
    * itself recursively
    * @return a mapping between the set of all string names of the members inherited from the passed{@link ClassElement} interface hierarchy, and the associated {@link ExecutableElement}
    */
   Map<String, ExecutableElement> computeInterfaceLookupMap(ClassElement classElt, Set<ClassElement> visitedInterfaces) {
     Map<String, ExecutableElement> resultMap = _interfaceLookup[classElt];
     if (resultMap != null) {
       return resultMap;
     } else {
       resultMap = new Map<String, ExecutableElement>();
     }
-    InterfaceType supertype2 = classElt.supertype;
-    ClassElement superclassElement = supertype2 != null ? supertype2.element : null;
-    List<InterfaceType> interfaces2 = classElt.interfaces;
-    if (superclassElement == null || interfaces2.length == 0) {
+    InterfaceType supertype = classElt.supertype;
+    ClassElement superclassElement = supertype != null ? supertype.element : null;
+    List<InterfaceType> interfaces = classElt.interfaces;
+    if (superclassElement == null || interfaces.length == 0) {
       _interfaceLookup[classElt] = resultMap;
       return resultMap;
     }
     List<Map<String, ExecutableElement>> lookupMaps = new List<Map<String, ExecutableElement>>();
     if (superclassElement != null) {
       if (!visitedInterfaces.contains(superclassElement)) {
         try {
           javaSetAdd(visitedInterfaces, superclassElement);
           lookupMaps.add(computeInterfaceLookupMap(superclassElement, visitedInterfaces));
         } finally {
           visitedInterfaces.remove(superclassElement);
         }
       } else {
         Map<String, ExecutableElement> map = _interfaceLookup[classElt];
         if (map != null) {
           lookupMaps.add(map);
         } else {
           _interfaceLookup[superclassElement] = resultMap;
           return resultMap;
         }
       }
     }
-    for (InterfaceType interfaceType in interfaces2) {
+    for (InterfaceType interfaceType in interfaces) {
       ClassElement interfaceElement = interfaceType.element;
       if (interfaceElement != null) {
         if (!visitedInterfaces.contains(interfaceElement)) {
           try {
             javaSetAdd(visitedInterfaces, interfaceElement);
             lookupMaps.add(computeInterfaceLookupMap(interfaceElement, visitedInterfaces));
           } finally {
             visitedInterfaces.remove(interfaceElement);
           }
         } else {
@@ skipping 18 matching lines @@
         if (!unionMap.containsKey(key)) {
           Set<ExecutableElement> set = new Set<ExecutableElement>();
           javaSetAdd(set, entry.getValue());
           unionMap[key] = set;
         } else {
           javaSetAdd(unionMap[key], entry.getValue());
         }
       }
     }
     if (superclassElement != null) {
-      List<MethodElement> methods2 = superclassElement.methods;
-      for (MethodElement method in methods2) {
+      List<MethodElement> methods = superclassElement.methods;
+      for (MethodElement method in methods) {
         if (method.isAccessibleIn(_library) && !method.isStatic()) {
           String key = method.name;
           if (!unionMap.containsKey(key)) {
             Set<ExecutableElement> set = new Set<ExecutableElement>();
             javaSetAdd(set, method);
             unionMap[key] = set;
           } else {
             javaSetAdd(unionMap[key], method);
           }
         }
       }
-      List<PropertyAccessorElement> accessors2 = superclassElement.accessors;
-      for (PropertyAccessorElement accessor in accessors2) {
+      List<PropertyAccessorElement> accessors = superclassElement.accessors;
+      for (PropertyAccessorElement accessor in accessors) {
         if (accessor.isAccessibleIn(_library) && !accessor.isStatic()) {
           String key = accessor.name;
           if (!unionMap.containsKey(key)) {
             Set<ExecutableElement> set = new Set<ExecutableElement>();
             javaSetAdd(set, accessor);
             unionMap[key] = set;
           } else {
             javaSetAdd(unionMap[key], accessor);
           }
         }
       }
     }
-    for (InterfaceType interfaceType in interfaces2) {
+    for (InterfaceType interfaceType in interfaces) {
       ClassElement interfaceElement = interfaceType.element;
       if (interfaceElement != null) {
-        List<MethodElement> methods3 = interfaceElement.methods;
-        for (MethodElement method in methods3) {
+        List<MethodElement> methods = interfaceElement.methods;
+        for (MethodElement method in methods) {
           if (method.isAccessibleIn(_library) && !method.isStatic()) {
             String key = method.name;
             if (!unionMap.containsKey(key)) {
               Set<ExecutableElement> set = new Set<ExecutableElement>();
               javaSetAdd(set, method);
               unionMap[key] = set;
             } else {
               javaSetAdd(unionMap[key], method);
             }
           }
         }
-        List<PropertyAccessorElement> accessors3 = interfaceElement.accessors;
-        for (PropertyAccessorElement accessor in accessors3) {
+        List<PropertyAccessorElement> accessors = interfaceElement.accessors;
+        for (PropertyAccessorElement accessor in accessors) {
           if (accessor.isAccessibleIn(_library) && !accessor.isStatic()) {
             String key = accessor.name;
             if (!unionMap.containsKey(key)) {
               Set<ExecutableElement> set = new Set<ExecutableElement>();
               javaSetAdd(set, accessor);
               unionMap[key] = set;
             } else {
               javaSetAdd(unionMap[key], accessor);
             }
           }
@@ skipping 67 matching lines @@
 
   /**
    * Given some {@link ClassElement}, this method finds and returns the {@link ExecutableElement} of
    * the passed name in the class element. Static members, members in super types and members not
    * accessible from the current library are not considered.
    * @param classElt the class element to query
    * @param memberName the name of the member to lookup in the class
    * @return the found {@link ExecutableElement}, or {@code null} if no such member was found
    */
   ExecutableElement lookupMemberInClass(ClassElement classElt, String memberName) {
-    List<MethodElement> methods2 = classElt.methods;
-    for (MethodElement method in methods2) {
+    List<MethodElement> methods = classElt.methods;
+    for (MethodElement method in methods) {
       if (memberName == method.name && method.isAccessibleIn(_library) && !method.isStatic()) {
         return method;
       }
     }
-    List<PropertyAccessorElement> accessors2 = classElt.accessors;
-    for (PropertyAccessorElement accessor in accessors2) {
+    List<PropertyAccessorElement> accessors = classElt.accessors;
+    for (PropertyAccessorElement accessor in accessors) {
       if (memberName == accessor.name && accessor.isAccessibleIn(_library) && !accessor.isStatic()) {
         return accessor;
       }
     }
     return null;
   }
 
   /**
    * Record the passed map with the set of all members (methods, getters and setters) in the class
    * into the passed map.
    * @param map some non-{@code null}
    * @param classElt the class element that will be recorded into the passed map
    */
   void recordMapWithClassMembers(Map<String, ExecutableElement> map, ClassElement classElt) {
-    List<MethodElement> methods2 = classElt.methods;
-    for (MethodElement method in methods2) {
+    List<MethodElement> methods = classElt.methods;
+    for (MethodElement method in methods) {
       if (method.isAccessibleIn(_library) && !method.isStatic()) {
         map[method.name] = method;
       }
     }
-    List<PropertyAccessorElement> accessors2 = classElt.accessors;
-    for (PropertyAccessorElement accessor in accessors2) {
+    List<PropertyAccessorElement> accessors = classElt.accessors;
+    for (PropertyAccessorElement accessor in accessors) {
       if (accessor.isAccessibleIn(_library) && !accessor.isStatic()) {
         map[accessor.name] = accessor;
       }
     }
   }
 
   /**
    * This method is used to report errors on when they are found computing inheritance information.
    * See {@link ErrorVerifier#checkForInconsistentMethodInheritance()} to see where these generated
    * error codes are reported back into the analysis engine.
@@ skipping 335 matching lines @@
   }
 
   /**
    * Build the library element for the given library.
    * @param library the library for which an element model is to be built
    * @return the library element that was built
    * @throws AnalysisException if the analysis could not be performed
    */
   LibraryElementImpl buildLibrary(Library library) {
     CompilationUnitBuilder builder = new CompilationUnitBuilder();
-    Source librarySource2 = library.librarySource;
-    CompilationUnit definingCompilationUnit2 = library.definingCompilationUnit;
-    CompilationUnitElementImpl definingCompilationUnitElement = builder.buildCompilationUnit(librarySource2, definingCompilationUnit2);
-    NodeList<Directive> directives2 = definingCompilationUnit2.directives;
+    Source librarySource = library.librarySource;
+    CompilationUnit definingCompilationUnit = library.definingCompilationUnit;
+    CompilationUnitElementImpl definingCompilationUnitElement = builder.buildCompilationUnit(librarySource, definingCompilationUnit);
+    NodeList<Directive> directives = definingCompilationUnit.directives;
     LibraryIdentifier libraryNameNode = null;
     bool hasPartDirective = false;
     FunctionElement entryPoint = findEntryPoint(definingCompilationUnitElement);
     List<Directive> directivesToResolve = new List<Directive>();
     List<CompilationUnitElementImpl> sourcedCompilationUnits = new List<CompilationUnitElementImpl>();
-    for (Directive directive in directives2) {
+    for (Directive directive in directives) {
       if (directive is LibraryDirective) {
         if (libraryNameNode == null) {
           libraryNameNode = ((directive as LibraryDirective)).name;
           directivesToResolve.add(directive);
         }
       } else if (directive is PartDirective) {
         PartDirective partDirective = directive as PartDirective;
         StringLiteral partUri = partDirective.uri;
         Source partSource = library.getSource(partDirective);
         if (partSource != null && partSource.exists()) {
           hasPartDirective = true;
           CompilationUnitElementImpl part = builder.buildCompilationUnit(partSource, library.getAST(partSource));
           part.uri = library.getUri(partDirective);
           String partLibraryName = getPartLibraryName(library, partSource, directivesToResolve);
           if (partLibraryName == null) {
-            _errorListener.onError(new AnalysisError.con2(librarySource2, partUri.offset, partUri.length, CompileTimeErrorCode.PART_OF_NON_PART, [partUri.toSource()]));
+            _errorListener.onError(new AnalysisError.con2(librarySource, partUri.offset, partUri.length, CompileTimeErrorCode.PART_OF_NON_PART, [partUri.toSource()]));
           } else if (libraryNameNode == null) {
           } else if (libraryNameNode.name != partLibraryName) {
-            _errorListener.onError(new AnalysisError.con2(librarySource2, partUri.offset, partUri.length, StaticWarningCode.PART_OF_DIFFERENT_LIBRARY, [libraryNameNode.name, partLibraryName]));
+            _errorListener.onError(new AnalysisError.con2(librarySource, partUri.offset, partUri.length, StaticWarningCode.PART_OF_DIFFERENT_LIBRARY, [libraryNameNode.name, partLibraryName]));
           }
           if (entryPoint == null) {
             entryPoint = findEntryPoint(part);
           }
           directive.element = part;
           sourcedCompilationUnits.add(part);
         }
       }
     }
     if (hasPartDirective && libraryNameNode == null) {
-      _errorListener.onError(new AnalysisError.con1(librarySource2, ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART, []));
+      _errorListener.onError(new AnalysisError.con1(librarySource, ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART, []));
     }
     LibraryElementImpl libraryElement = new LibraryElementImpl(_analysisContext, libraryNameNode);
     libraryElement.definingCompilationUnit = definingCompilationUnitElement;
     if (entryPoint != null) {
       libraryElement.entryPoint = entryPoint;
     }
     int sourcedUnitCount = sourcedCompilationUnits.length;
     libraryElement.parts = new List.from(sourcedCompilationUnits);
     for (Directive directive in directivesToResolve) {
       directive.element = libraryElement;
@@ skipping 48 matching lines @@
    * @param directivesToResolve a list of directives that should be resolved to the library being
    * built
    * @return the name of the library that the given part is declared to be a part of
    */
   String getPartLibraryName(Library library, Source partSource, List<Directive> directivesToResolve) {
     try {
       CompilationUnit partUnit = library.getAST(partSource);
       for (Directive directive in partUnit.directives) {
         if (directive is PartOfDirective) {
           directivesToResolve.add(directive);
-          LibraryIdentifier libraryName2 = ((directive as PartOfDirective)).libraryName;
-          if (libraryName2 != null) {
-            return libraryName2.name;
+          LibraryIdentifier libraryName = ((directive as PartOfDirective)).libraryName;
+          if (libraryName != null) {
+            return libraryName.name;
           }
         }
       }
     } on AnalysisException catch (exception) {
     }
     return null;
   }
 
   /**
    * Look through all of the compilation units defined for the given library, looking for getters
    * and setters that are defined in different compilation units but that have the same names. If
    * any are found, make sure that they have the same variable element.
    * @param libraryElement the library defining the compilation units to be processed
    */
   void patchTopLevelAccessors(LibraryElementImpl libraryElement) {
     Map<String, PropertyAccessorElement> getters = new Map<String, PropertyAccessorElement>();
     List<PropertyAccessorElement> setters = new List<PropertyAccessorElement>();
     collectAccessors(getters, setters, libraryElement.definingCompilationUnit);
     for (CompilationUnitElement unit in libraryElement.parts) {
       collectAccessors(getters, setters, unit);
     }
     for (PropertyAccessorElement setter in setters) {
       PropertyAccessorElement getter = getters[setter.displayName];
       if (getter != null) {
-        PropertyInducingElementImpl variable2 = getter.variable as PropertyInducingElementImpl;
-        variable2.setter = setter;
-        ((setter as PropertyAccessorElementImpl)).variable = variable2;
+        PropertyInducingElementImpl variable = getter.variable as PropertyInducingElementImpl;
+        variable.setter = setter;
+        ((setter as PropertyAccessorElementImpl)).variable = variable;
       }
     }
   }
 }
 /**
  * Instances of the class {@code LibraryResolver} are used to resolve one or more mutually dependent
  * libraries within a single context.
  * @coverage dart.engine.resolver
  */
 class LibraryResolver {
@@ skipping 285 matching lines @@
           if (exportedLibrary != null) {
             LibraryElement exportedLibraryElement = exportedLibrary.libraryElement;
             if (exportedLibraryElement != null) {
               exportElement.exportedLibrary = exportedLibraryElement;
             }
             directive.element = exportElement;
             exports.add(exportElement);
           }
         }
       }
-      Source librarySource2 = library.librarySource;
-      if (!library.explicitlyImportsCore && _coreLibrarySource != librarySource2) {
+      Source librarySource = library.librarySource;
+      if (!library.explicitlyImportsCore && _coreLibrarySource != librarySource) {
         ImportElementImpl importElement = new ImportElementImpl();
         importElement.importedLibrary = _coreLibrary.libraryElement;
         importElement.synthetic = true;
         imports.add(importElement);
       }
-      LibraryElementImpl libraryElement2 = library.libraryElement;
-      libraryElement2.imports = new List.from(imports);
-      libraryElement2.exports = new List.from(exports);
+      LibraryElementImpl libraryElement = library.libraryElement;
+      libraryElement.imports = new List.from(imports);
+      libraryElement.exports = new List.from(exports);
     }
   }
 
   /**
    * Build element models for all of the libraries in the current cycle.
    * @throws AnalysisException if any of the element models cannot be built
    */
   void buildElementModels() {
     for (Library library in _librariesInCycles) {
       LibraryElementBuilder builder = new LibraryElementBuilder(this);
@@ skipping 159 matching lines @@
     _libraryMap[librarySource] = library;
     return library;
   }
 
   /**
    * Return {@code true} if and only if the passed {@link CompilationUnit} has a part-of directive.
    * @param node the {@link CompilationUnit} to test
    * @return {@code true} if and only if the passed {@link CompilationUnit} has a part-of directive
    */
   bool doesCompilationUnitHavePartOfDirective(CompilationUnit node) {
-    NodeList<Directive> directives2 = node.directives;
-    for (Directive directive in directives2) {
+    NodeList<Directive> directives = node.directives;
+    for (Directive directive in directives) {
       if (directive is PartOfDirective) {
         return true;
       }
     }
     return false;
   }
 
   /**
    * Return an array containing the lexical identifiers associated with the nodes in the given list.
    * @param names the AST nodes representing the identifiers
@@ skipping 159 matching lines @@
     }
     return null;
   }
   Object visitAssertStatement(AssertStatement node) {
     super.visitAssertStatement(node);
     propagateTrueState(node.condition);
     return null;
   }
   Object visitBinaryExpression(BinaryExpression node) {
     sc.TokenType operatorType = node.operator.type;
-    Expression leftOperand2 = node.leftOperand;
-    Expression rightOperand2 = node.rightOperand;
+    Expression leftOperand = node.leftOperand;
+    Expression rightOperand = node.rightOperand;
     if (identical(operatorType, sc.TokenType.AMPERSAND_AMPERSAND)) {
-      safelyVisit(leftOperand2);
-      if (rightOperand2 != null) {
+      safelyVisit(leftOperand);
+      if (rightOperand != null) {
         try {
           _overrideManager.enterScope();
-          propagateTrueState(leftOperand2);
-          rightOperand2.accept(this);
+          propagateTrueState(leftOperand);
+          rightOperand.accept(this);
         } finally {
           _overrideManager.exitScope();
         }
       }
     } else if (identical(operatorType, sc.TokenType.BAR_BAR)) {
-      safelyVisit(leftOperand2);
-      if (rightOperand2 != null) {
+      safelyVisit(leftOperand);
+      if (rightOperand != null) {
         try {
           _overrideManager.enterScope();
-          propagateFalseState(leftOperand2);
-          rightOperand2.accept(this);
+          propagateFalseState(leftOperand);
+          rightOperand.accept(this);
         } finally {
           _overrideManager.exitScope();
         }
       }
     } else {
-      safelyVisit(leftOperand2);
-      safelyVisit(rightOperand2);
+      safelyVisit(leftOperand);
+      safelyVisit(rightOperand);
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
   Object visitBreakStatement(BreakStatement node) {
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
@@ skipping 32 matching lines @@
         declaration.accept(this);
       }
     } finally {
       _overrideManager.exitScope();
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
   Object visitConditionalExpression(ConditionalExpression node) {
-    Expression condition2 = node.condition;
-    safelyVisit(condition2);
-    Expression thenExpression2 = node.thenExpression;
-    if (thenExpression2 != null) {
+    Expression condition = node.condition;
+    safelyVisit(condition);
+    Expression thenExpression = node.thenExpression;
+    if (thenExpression != null) {
       try {
         _overrideManager.enterScope();
-        propagateTrueState(condition2);
-        thenExpression2.accept(this);
+        propagateTrueState(condition);
+        thenExpression.accept(this);
       } finally {
         _overrideManager.exitScope();
       }
     }
-    Expression elseExpression2 = node.elseExpression;
-    if (elseExpression2 != null) {
+    Expression elseExpression = node.elseExpression;
+    if (elseExpression != null) {
       try {
         _overrideManager.enterScope();
-        propagateFalseState(condition2);
-        elseExpression2.accept(this);
+        propagateFalseState(condition);
+        elseExpression.accept(this);
       } finally {
         _overrideManager.exitScope();
       }
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
-    bool thenIsAbrupt = isAbruptTermination(thenExpression2);
-    bool elseIsAbrupt = isAbruptTermination(elseExpression2);
+    bool thenIsAbrupt = isAbruptTermination(thenExpression);
+    bool elseIsAbrupt = isAbruptTermination(elseExpression);
     if (elseIsAbrupt && !thenIsAbrupt) {
-      propagateTrueState(condition2);
-      propagateState(thenExpression2);
+      propagateTrueState(condition);
+      propagateState(thenExpression);
     } else if (thenIsAbrupt && !elseIsAbrupt) {
-      propagateFalseState(condition2);
-      propagateState(elseExpression2);
+      propagateFalseState(condition);
+      propagateState(elseExpression);
     }
     return null;
   }
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
       super.visitConstructorDeclaration(node);
     } finally {
       _enclosingFunction = outerFunction;
@@ skipping 81 matching lines @@
       _overrideManager.enterScope();
       super.visitFunctionExpression(node);
     } finally {
       _overrideManager.exitScope();
       _enclosingFunction = outerFunction;
     }
     return null;
   }
   Object visitHideCombinator(HideCombinator node) => null;
   Object visitIfStatement(IfStatement node) {
-    Expression condition2 = node.condition;
-    safelyVisit(condition2);
+    Expression condition = node.condition;
+    safelyVisit(condition);
     Map<Element, Type2> thenOverrides = null;
-    Statement thenStatement2 = node.thenStatement;
-    if (thenStatement2 != null) {
+    Statement thenStatement = node.thenStatement;
+    if (thenStatement != null) {
       try {
         _overrideManager.enterScope();
-        propagateTrueState(condition2);
-        thenStatement2.accept(this);
+        propagateTrueState(condition);
+        thenStatement.accept(this);
       } finally {
         thenOverrides = _overrideManager.captureLocalOverrides();
         _overrideManager.exitScope();
       }
     }
     Map<Element, Type2> elseOverrides = null;
-    Statement elseStatement2 = node.elseStatement;
-    if (elseStatement2 != null) {
+    Statement elseStatement = node.elseStatement;
+    if (elseStatement != null) {
       try {
         _overrideManager.enterScope();
-        propagateFalseState(condition2);
-        elseStatement2.accept(this);
+        propagateFalseState(condition);
+        elseStatement.accept(this);
       } finally {
         elseOverrides = _overrideManager.captureLocalOverrides();
         _overrideManager.exitScope();
       }
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
-    bool thenIsAbrupt = isAbruptTermination2(thenStatement2);
-    bool elseIsAbrupt = isAbruptTermination2(elseStatement2);
+    bool thenIsAbrupt = isAbruptTermination2(thenStatement);
+    bool elseIsAbrupt = isAbruptTermination2(elseStatement);
     if (elseIsAbrupt && !thenIsAbrupt) {
-      propagateTrueState(condition2);
+      propagateTrueState(condition);
       if (thenOverrides != null) {
         _overrideManager.applyOverrides(thenOverrides);
       }
     } else if (thenIsAbrupt && !elseIsAbrupt) {
-      propagateFalseState(condition2);
+      propagateFalseState(condition);
       if (elseOverrides != null) {
         _overrideManager.applyOverrides(elseOverrides);
       }
     }
     return null;
   }
   Object visitLabel(Label node) => null;
   Object visitLibraryIdentifier(LibraryIdentifier node) => null;
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
@@ skipping 67 matching lines @@
       super.visitTopLevelVariableDeclaration(node);
     } finally {
       Map<Element, Type2> overrides = _overrideManager.captureOverrides(node.variables);
       _overrideManager.exitScope();
       _overrideManager.applyOverrides(overrides);
     }
     return null;
   }
   Object visitTypeName(TypeName node) => null;
   Object visitWhileStatement(WhileStatement node) {
-    Expression condition2 = node.condition;
-    safelyVisit(condition2);
-    Statement body2 = node.body;
-    if (body2 != null) {
+    Expression condition = node.condition;
+    safelyVisit(condition);
+    Statement body = node.body;
+    if (body != null) {
       try {
         _overrideManager.enterScope();
-        propagateTrueState(condition2);
-        body2.accept(this);
+        propagateTrueState(condition);
+        body.accept(this);
       } finally {
         _overrideManager.exitScope();
       }
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
 
   /**
@@ skipping 46 matching lines @@
       if (!variable.isConst() && !variable.isFinal()) {
         return;
       }
     }
     Type2 currentType = getBestType(element);
     if (currentType == null || !currentType.isMoreSpecificThan(potentialType)) {
       _overrideManager.setType(element, potentialType);
     }
   }
   void visitForEachStatementInScope(ForEachStatement node) {
-    Expression iterator2 = node.iterator;
-    safelyVisit(iterator2);
-    DeclaredIdentifier loopVariable2 = node.loopVariable;
-    safelyVisit(loopVariable2);
-    Statement body2 = node.body;
-    if (body2 != null) {
+    Expression iterator = node.iterator;
+    safelyVisit(iterator);
+    DeclaredIdentifier loopVariable = node.loopVariable;
+    safelyVisit(loopVariable);
+    Statement body = node.body;
+    if (body != null) {
       try {
         _overrideManager.enterScope();
-        if (loopVariable2 != null && iterator2 != null) {
-          LocalVariableElement loopElement = loopVariable2.element;
+        if (loopVariable != null && iterator != null) {
+          LocalVariableElement loopElement = loopVariable.element;
           if (loopElement != null) {
-            override(loopElement, getIteratorElementType(iterator2));
+            override(loopElement, getIteratorElementType(iterator));
           }
         }
-        body2.accept(this);
+        body.accept(this);
       } finally {
         _overrideManager.exitScope();
       }
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
   }
   void visitForStatementInScope(ForStatement node) {
     safelyVisit(node.variables);
     safelyVisit(node.initialization);
@@ skipping 70 matching lines @@
    * following the given statement will not be reached).
    * @param statement the statement being tested
    * @return {@code true} if the given statement terminates abruptly
    */
   bool isAbruptTermination2(Statement statement) {
     if (statement is ReturnStatement || statement is BreakStatement || statement is ContinueStatement) {
       return true;
     } else if (statement is ExpressionStatement) {
       return isAbruptTermination(((statement as ExpressionStatement)).expression);
     } else if (statement is Block) {
-      NodeList<Statement> statements2 = ((statement as Block)).statements;
-      int size2 = statements2.length;
-      if (size2 == 0) {
+      NodeList<Statement> statements = ((statement as Block)).statements;
+      int size = statements.length;
+      if (size == 0) {
         return false;
       }
-      return isAbruptTermination2(statements2[size2 - 1]);
+      return isAbruptTermination2(statements[size - 1]);
     }
     return false;
   }
 
   /**
    * Propagate any type information that results from knowing that the given condition will have
    * been evaluated to 'false'.
    * @param condition the condition that will have evaluated to 'false'
    */
   void propagateFalseState(Expression condition) {
@@ skipping 111 matching lines @@
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
   ScopedVisitor.con1(Library library, Source source2, TypeProvider typeProvider2) {
     _jtd_constructor_275_impl(library, source2, typeProvider2);
   }
   _jtd_constructor_275_impl(Library library, Source source2, TypeProvider typeProvider2) {
     this._definingLibrary = library.libraryElement;
     this._source = source2;
-    LibraryScope libraryScope2 = library.libraryScope;
-    this._errorListener = libraryScope2.errorListener;
-    this._nameScope = libraryScope2;
+    LibraryScope libraryScope = library.libraryScope;
+    this._errorListener = libraryScope.errorListener;
+    this._nameScope = libraryScope;
     this._typeProvider = typeProvider2;
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    * @param definingLibrary the element for the library containing the compilation unit being
    * visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
@@ skipping 73 matching lines @@
     Scope outerScope = _nameScope;
     try {
       _nameScope = new FunctionScope(_nameScope, node.element);
       super.visitConstructorDeclaration(node);
     } finally {
       _nameScope = outerScope;
     }
     return null;
   }
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
-    VariableElement element2 = node.element;
-    if (element2 != null) {
-      _nameScope.define(element2);
+    VariableElement element = node.element;
+    if (element != null) {
+      _nameScope.define(element);
     }
     super.visitDeclaredIdentifier(node);
     return null;
   }
   Object visitDoStatement(DoStatement node) {
     LabelScope outerScope = _labelScope;
     _labelScope = new LabelScope.con1(outerScope, false, false);
     try {
       super.visitDoStatement(node);
     } finally {
@@ skipping 121 matching lines @@
     }
     try {
       super.visitSwitchStatement(node);
     } finally {
       _labelScope = outerScope;
     }
     return null;
   }
   Object visitVariableDeclaration(VariableDeclaration node) {
     if (node.parent.parent is! TopLevelVariableDeclaration && node.parent.parent is! FieldDeclaration) {
-      VariableElement element2 = node.element;
-      if (element2 != null) {
-        _nameScope.define(element2);
+      VariableElement element = node.element;
+      if (element != null) {
+        _nameScope.define(element);
       }
     }
     super.visitVariableDeclaration(node);
     return null;
   }
   Object visitWhileStatement(WhileStatement node) {
     LabelScope outerScope = _labelScope;
     _labelScope = new LabelScope.con1(outerScope, false, false);
     try {
       super.visitWhileStatement(node);
@@ skipping 288 matching lines @@
    * A compound assignment of the form <i>v op= e</i> is equivalent to <i>v = v op e</i>. A compound
    * assignment of the form <i>C.v op= e</i> is equivalent to <i>C.v = C.v op e</i>. A compound
    * assignment of the form <i>e<sub>1</sub>.v op= e<sub>2</sub></i> is equivalent to <i>((x) => x.v
    * = x.v op e<sub>2</sub>)(e<sub>1</sub>)</i> where <i>x</i> is a variable that is not used in
    * <i>e<sub>2</sub></i>. A compound assignment of the form <i>e<sub>1</sub>\[e<sub>2</sub>\] op=
    * e<sub>3</sub></i> is equivalent to <i>((a, i) => a\[i\] = a\[i\] op e<sub>3</sub>)(e<sub>1</sub>,
    * e<sub>2</sub>)</i> where <i>a</i> and <i>i</i> are a variables that are not used in
    * <i>e<sub>3</sub></i>.</blockquote>
    */
   Object visitAssignmentExpression(AssignmentExpression node) {
-    sc.TokenType operator2 = node.operator.type;
-    if (identical(operator2, sc.TokenType.EQ)) {
-      Expression rightHandSide2 = node.rightHandSide;
-      Type2 staticType = getStaticType(rightHandSide2);
+    sc.TokenType operator = node.operator.type;
+    if (identical(operator, sc.TokenType.EQ)) {
+      Expression rightHandSide = node.rightHandSide;
+      Type2 staticType = getStaticType(rightHandSide);
       recordStaticType(node, staticType);
       Type2 overrideType = staticType;
-      Type2 propagatedType = getPropagatedType(rightHandSide2);
+      Type2 propagatedType = getPropagatedType(rightHandSide);
       if (propagatedType != null) {
         if (propagatedType.isMoreSpecificThan(staticType)) {
           recordPropagatedType(node, propagatedType);
         }
         overrideType = propagatedType;
       }
       VariableElement element = _resolver.getOverridableElement(node.leftHandSide);
       if (element != null) {
         _resolver.override(element, overrideType);
       }
@@ skipping 242 matching lines @@
    * The Dart Language Specification, 12.11.1: <blockquote>The static type of a new expression of
    * either the form <i>new T.id(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> or the form <i>new
    * T(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> is <i>T</i>.</blockquote>
    * <p>
    * The Dart Language Specification, 12.11.2: <blockquote>The static type of a constant object
    * expression of either the form <i>const T.id(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> or the
    * form <i>const T(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> is <i>T</i>. </blockquote>
    */
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     recordStaticType(node, node.constructorName.type.type);
-    ConstructorElement element2 = node.element;
-    if (element2 != null && "Element" == element2.enclosingElement.name && "tag" == element2.name) {
-      LibraryElement library2 = element2.library;
-      if (isHtmlLibrary(library2)) {
-        Type2 returnType = getFirstArgumentAsType2(library2, node.argumentList, _HTML_ELEMENT_TO_CLASS_MAP);
+    ConstructorElement element = node.element;
+    if (element != null && "Element" == element.enclosingElement.name && "tag" == element.name) {
+      LibraryElement library = element.library;
+      if (isHtmlLibrary(library)) {
+        Type2 returnType = getFirstArgumentAsType2(library, node.argumentList, _HTML_ELEMENT_TO_CLASS_MAP);
         if (returnType != null) {
           recordPropagatedType(node, returnType);
         }
       }
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.3: <blockquote>The static type of an integer literal is{@code int}.</blockquote>
@@ skipping 16 matching lines @@
 
   /**
    * The Dart Language Specification, 12.6: <blockquote>The static type of a list literal of the
    * form <i><b>const</b> &lt;E&gt;\[e<sub>1</sub>, &hellip;, e<sub>n</sub>\]</i> or the form
    * <i>&lt;E&gt;\[e<sub>1</sub>, &hellip;, e<sub>n</sub>\]</i> is {@code List&lt;E&gt;}. The static
    * type a list literal of the form <i><b>const</b> \[e<sub>1</sub>, &hellip;, e<sub>n</sub>\]</i> or
    * the form <i>\[e<sub>1</sub>, &hellip;, e<sub>n</sub>\]</i> is {@code List&lt;dynamic&gt;}.</blockquote>
    */
   Object visitListLiteral(ListLiteral node) {
     Type2 staticType = _dynamicType;
-    TypeArgumentList typeArguments2 = node.typeArguments;
-    if (typeArguments2 != null) {
-      NodeList<TypeName> arguments2 = typeArguments2.arguments;
-      if (arguments2 != null && arguments2.length == 1) {
-        TypeName argumentTypeName = arguments2[0];
+    TypeArgumentList typeArguments = node.typeArguments;
+    if (typeArguments != null) {
+      NodeList<TypeName> arguments = typeArguments.arguments;
+      if (arguments != null && arguments.length == 1) {
+        TypeName argumentTypeName = arguments[0];
         Type2 argumentType = getType2(argumentTypeName);
         if (argumentType != null) {
           staticType = argumentType;
         }
       }
     }
     recordStaticType(node, _typeProvider.listType.substitute5(<Type2> [staticType]));
-    NodeList<Expression> elements2 = node.elements;
-    int count = elements2.length;
+    NodeList<Expression> elements = node.elements;
+    int count = elements.length;
     if (count > 0) {
-      Type2 propagatedType = getBestType(elements2[0]);
+      Type2 propagatedType = getBestType(elements[0]);
       for (int i = 1; i < count; i++) {
-        Type2 elementType = getBestType(elements2[i]);
+        Type2 elementType = getBestType(elements[i]);
         if (propagatedType != elementType) {
           propagatedType = _dynamicType;
         } else {
           propagatedType = propagatedType.getLeastUpperBound(elementType);
           if (propagatedType == null) {
             propagatedType = _dynamicType;
           }
         }
       }
       if (propagatedType.isMoreSpecificThan(staticType)) {
@@ skipping 11 matching lines @@
    * map literal of the form <i><b>const</b> {k<sub>1</sub>:e<sub>1</sub>, &hellip;,
    * k<sub>n</sub>:e<sub>n</sub>}</i> or the form <i>{k<sub>1</sub>:e<sub>1</sub>, &hellip;,
    * k<sub>n</sub>:e<sub>n</sub>}</i> is {@code Map&lt;String, dynamic&gt;}.
    * <p>
    * It is a compile-time error if the first type argument to a map literal is not
    * <i>String</i>.</blockquote>
    */
   Object visitMapLiteral(MapLiteral node) {
     Type2 staticKeyType = _dynamicType;
     Type2 staticValueType = _dynamicType;
-    TypeArgumentList typeArguments2 = node.typeArguments;
-    if (typeArguments2 != null) {
-      NodeList<TypeName> arguments2 = typeArguments2.arguments;
-      if (arguments2 != null && arguments2.length == 2) {
-        TypeName entryKeyTypeName = arguments2[0];
+    TypeArgumentList typeArguments = node.typeArguments;
+    if (typeArguments != null) {
+      NodeList<TypeName> arguments = typeArguments.arguments;
+      if (arguments != null && arguments.length == 2) {
+        TypeName entryKeyTypeName = arguments[0];
         Type2 entryKeyType = getType2(entryKeyTypeName);
         if (entryKeyType != null) {
           staticKeyType = entryKeyType;
         }
-        TypeName entryValueTypeName = arguments2[1];
+        TypeName entryValueTypeName = arguments[1];
         Type2 entryValueType = getType2(entryValueTypeName);
         if (entryValueType != null) {
           staticValueType = entryValueType;
         }
       }
     }
     recordStaticType(node, _typeProvider.mapType.substitute5(<Type2> [staticKeyType, staticValueType]));
-    NodeList<MapLiteralEntry> entries2 = node.entries;
-    int count = entries2.length;
+    NodeList<MapLiteralEntry> entries = node.entries;
+    int count = entries.length;
     if (count > 0) {
-      MapLiteralEntry entry = entries2[0];
+      MapLiteralEntry entry = entries[0];
       Type2 propagatedKeyType = getBestType(entry.key);
       Type2 propagatedValueType = getBestType(entry.value);
       for (int i = 1; i < count; i++) {
-        entry = entries2[i];
+        entry = entries[i];
         Type2 elementKeyType = getBestType(entry.key);
         if (propagatedKeyType != elementKeyType) {
           propagatedKeyType = _dynamicType;
         } else {
           propagatedKeyType = propagatedKeyType.getLeastUpperBound(elementKeyType);
           if (propagatedKeyType == null) {
             propagatedKeyType = _dynamicType;
           }
         }
         Type2 elementValueType = getBestType(entry.value);
@@ skipping 64 matching lines @@
       staticMethodElement = methodNameNode.element;
     }
     Type2 staticType = computeReturnType(staticMethodElement);
     recordStaticType(node, staticType);
     String methodName = methodNameNode.name;
     if (methodName == "\$dom_createEvent") {
       Expression target = node.realTarget;
       if (target != null) {
         Type2 targetType = getBestType(target);
         if (targetType is InterfaceType && (targetType.name == "HtmlDocument" || targetType.name == "Document")) {
-          LibraryElement library2 = targetType.element.library;
-          if (isHtmlLibrary(library2)) {
-            Type2 returnType = getFirstArgumentAsType(library2, node.argumentList);
+          LibraryElement library = targetType.element.library;
+          if (isHtmlLibrary(library)) {
+            Type2 returnType = getFirstArgumentAsType(library, node.argumentList);
             if (returnType != null) {
               recordPropagatedType(node, returnType);
             }
           }
         }
       }
     } else if (methodName == "query") {
       Expression target = node.realTarget;
       if (target == null) {
         Element methodElement = methodNameNode.element;
         if (methodElement != null) {
-          LibraryElement library3 = methodElement.library;
-          if (isHtmlLibrary(library3)) {
-            Type2 returnType = getFirstArgumentAsQuery(library3, node.argumentList);
+          LibraryElement library = methodElement.library;
+          if (isHtmlLibrary(library)) {
+            Type2 returnType = getFirstArgumentAsQuery(library, node.argumentList);
             if (returnType != null) {
               recordPropagatedType(node, returnType);
             }
           }
         }
       } else {
         Type2 targetType = getBestType(target);
         if (targetType is InterfaceType && (targetType.name == "HtmlDocument" || targetType.name == "Document")) {
-          LibraryElement library4 = targetType.element.library;
-          if (isHtmlLibrary(library4)) {
-            Type2 returnType = getFirstArgumentAsQuery(library4, node.argumentList);
+          LibraryElement library = targetType.element.library;
+          if (isHtmlLibrary(library)) {
+            Type2 returnType = getFirstArgumentAsQuery(library, node.argumentList);
             if (returnType != null) {
               recordPropagatedType(node, returnType);
             }
           }
         }
       }
     } else if (methodName == "\$dom_createElement") {
       Expression target = node.realTarget;
       Type2 targetType = getBestType(target);
       if (targetType is InterfaceType && (targetType.name == "HtmlDocument" || targetType.name == "Document")) {
-        LibraryElement library5 = targetType.element.library;
-        if (isHtmlLibrary(library5)) {
-          Type2 returnType = getFirstArgumentAsQuery(library5, node.argumentList);
+        LibraryElement library = targetType.element.library;
+        if (isHtmlLibrary(library)) {
+          Type2 returnType = getFirstArgumentAsQuery(library, node.argumentList);
           if (returnType != null) {
             recordPropagatedType(node, returnType);
           }
         }
       }
     } else if (methodName == "JS") {
       Type2 returnType = getFirstArgumentAsType(_typeProvider.objectType.element.library, node.argumentList);
       if (returnType != null) {
         recordPropagatedType(node, returnType);
       }
     } else {
       Element propagatedElement = methodNameNode.element;
       if (propagatedElement != staticMethodElement) {
         Type2 propagatedType = computeReturnType(propagatedElement);
         if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
           recordPropagatedType(node, propagatedType);
         }
       }
     }
     return null;
   }
   Object visitNamedExpression(NamedExpression node) {
-    Expression expression2 = node.expression;
-    recordStaticType(node, getStaticType(expression2));
-    recordPropagatedType(node, getPropagatedType(expression2));
+    Expression expression = node.expression;
+    recordStaticType(node, getStaticType(expression));
+    recordPropagatedType(node, getPropagatedType(expression));
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.2: <blockquote>The static type of {@code null} is bottom.
    * </blockquote>
    */
   Object visitNullLiteral(NullLiteral node) {
     recordStaticType(node, _typeProvider.bottomType);
     return null;
   }
   Object visitParenthesizedExpression(ParenthesizedExpression node) {
-    Expression expression2 = node.expression;
-    recordStaticType(node, getStaticType(expression2));
-    recordPropagatedType(node, getPropagatedType(expression2));
+    Expression expression = node.expression;
+    recordStaticType(node, getStaticType(expression));
+    recordPropagatedType(node, getPropagatedType(expression));
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.28: <blockquote>A postfix expression of the form
    * <i>v++</i>, where <i>v</i> is an identifier, is equivalent to <i>(){var r = v; v = r + 1;
    * return r}()</i>.
    * <p>
    * A postfix expression of the form <i>C.v++</i> is equivalent to <i>(){var r = C.v; C.v = r + 1;
    * return r}()</i>.
@@ skipping 10 matching lines @@
    * A postfix expression of the form <i>C.v--</i> is equivalent to <i>(){var r = C.v; C.v = r - 1;
    * return r}()</i>.
    * <p>
    * A postfix expression of the form <i>e1.v--</i> is equivalent to <i>(x){var r = x.v; x.v = r -
    * 1; return r}(e1)</i>.
    * <p>
    * A postfix expression of the form <i>e1\[e2\]--</i> is equivalent to <i>(a, i){var r = a\[i\]; a\[i\]
    * = r - 1; return r}(e1, e2)</i></blockquote>
    */
   Object visitPostfixExpression(PostfixExpression node) {
-    Expression operand2 = node.operand;
-    Type2 staticType = getStaticType(operand2);
-    sc.TokenType operator2 = node.operator.type;
-    if (identical(operator2, sc.TokenType.MINUS_MINUS) || identical(operator2, sc.TokenType.PLUS_PLUS)) {
-      Type2 intType2 = _typeProvider.intType;
-      if (identical(getStaticType(node.operand), intType2)) {
-        staticType = intType2;
+    Expression operand = node.operand;
+    Type2 staticType = getStaticType(operand);
+    sc.TokenType operator = node.operator.type;
+    if (identical(operator, sc.TokenType.MINUS_MINUS) || identical(operator, sc.TokenType.PLUS_PLUS)) {
+      Type2 intType = _typeProvider.intType;
+      if (identical(getStaticType(node.operand), intType)) {
+        staticType = intType;
       }
     }
     recordStaticType(node, staticType);
-    recordPropagatedType(node, getPropagatedType(operand2));
+    recordPropagatedType(node, getPropagatedType(operand));
     return null;
   }
 
   /**
    * See {@link #visitSimpleIdentifier(SimpleIdentifier)}.
    */
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     SimpleIdentifier prefixedIdentifier = node.identifier;
-    Element element2 = prefixedIdentifier.element;
+    Element element = prefixedIdentifier.element;
     Type2 staticType = _dynamicType;
-    if (element2 is ClassElement) {
+    if (element is ClassElement) {
       if (isNotTypeLiteral(node)) {
-        staticType = ((element2 as ClassElement)).type;
+        staticType = ((element as ClassElement)).type;
       } else {
         staticType = _typeProvider.typeType;
       }
-    } else if (element2 is FunctionTypeAliasElement) {
-      staticType = ((element2 as FunctionTypeAliasElement)).type;
-    } else if (element2 is MethodElement) {
-      staticType = ((element2 as MethodElement)).type;
-    } else if (element2 is PropertyAccessorElement) {
-      staticType = getType((element2 as PropertyAccessorElement), node.prefix.staticType);
-    } else if (element2 is ExecutableElement) {
-      staticType = ((element2 as ExecutableElement)).type;
-    } else if (element2 is TypeVariableElement) {
-      staticType = ((element2 as TypeVariableElement)).type;
-    } else if (element2 is VariableElement) {
-      staticType = ((element2 as VariableElement)).type;
+    } else if (element is FunctionTypeAliasElement) {
+      staticType = ((element as FunctionTypeAliasElement)).type;
+    } else if (element is MethodElement) {
+      staticType = ((element as MethodElement)).type;
+    } else if (element is PropertyAccessorElement) {
+      staticType = getType((element as PropertyAccessorElement), node.prefix.staticType);
+    } else if (element is ExecutableElement) {
+      staticType = ((element as ExecutableElement)).type;
+    } else if (element is TypeVariableElement) {
+      staticType = ((element as TypeVariableElement)).type;
+    } else if (element is VariableElement) {
+      staticType = ((element as VariableElement)).type;
     }
     recordStaticType(prefixedIdentifier, staticType);
     recordStaticType(node, staticType);
-    Type2 propagatedType = _overrideManager.getType(element2);
+    Type2 propagatedType = _overrideManager.getType(element);
     if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
       recordPropagatedType(prefixedIdentifier, propagatedType);
       recordPropagatedType(node, propagatedType);
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.27: <blockquote>A unary expression <i>u</i> of the form
    * <i>op e</i> is equivalent to a method invocation <i>expression e.op()</i>. An expression of the
    * form <i>op super</i> is equivalent to the method invocation <i>super.op()<i>.</blockquote>
    */
   Object visitPrefixExpression(PrefixExpression node) {
-    sc.TokenType operator2 = node.operator.type;
-    if (identical(operator2, sc.TokenType.BANG)) {
+    sc.TokenType operator = node.operator.type;
+    if (identical(operator, sc.TokenType.BANG)) {
       recordStaticType(node, _typeProvider.boolType);
     } else {
       ExecutableElement staticMethodElement = node.staticElement;
       Type2 staticType = computeReturnType(staticMethodElement);
-      if (identical(operator2, sc.TokenType.MINUS_MINUS) || identical(operator2, sc.TokenType.PLUS_PLUS)) {
-        Type2 intType2 = _typeProvider.intType;
-        if (identical(getStaticType(node.operand), intType2)) {
-          staticType = intType2;
+      if (identical(operator, sc.TokenType.MINUS_MINUS) || identical(operator, sc.TokenType.PLUS_PLUS)) {
+        Type2 intType = _typeProvider.intType;
+        if (identical(getStaticType(node.operand), intType)) {
+          staticType = intType;
         }
       }
       recordStaticType(node, staticType);
       MethodElement propagatedMethodElement = node.element;
       if (propagatedMethodElement != staticMethodElement) {
         Type2 propagatedType = computeReturnType(propagatedMethodElement);
         if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
           recordPropagatedType(node, propagatedType);
         }
       }
@@ skipping 38 matching lines @@
    * <p>
    * The static type of <i>i</i> is the declared return type of <i>C.m</i> if it exists or dynamic
    * otherwise.
    * <p>
    * ... a top-level getter invocation <i>i</i> of the form <i>m</i>, where <i>m</i> is an
    * identifier ...
    * <p>
    * The static type of <i>i</i> is the declared return type of <i>m</i>.</blockquote>
    */
   Object visitPropertyAccess(PropertyAccess node) {
-    SimpleIdentifier propertyName2 = node.propertyName;
-    Element element2 = propertyName2.element;
+    SimpleIdentifier propertyName = node.propertyName;
+    Element element = propertyName.element;
     Type2 staticType = _dynamicType;
-    if (element2 is MethodElement) {
-      staticType = ((element2 as MethodElement)).type;
-    } else if (element2 is PropertyAccessorElement) {
-      staticType = getType((element2 as PropertyAccessorElement), node.target != null ? getStaticType(node.target) : null);
+    if (element is MethodElement) {
+      staticType = ((element as MethodElement)).type;
+    } else if (element is PropertyAccessorElement) {
+      staticType = getType((element as PropertyAccessorElement), node.target != null ? getStaticType(node.target) : null);
     } else {
     }
-    recordStaticType(propertyName2, staticType);
+    recordStaticType(propertyName, staticType);
     recordStaticType(node, staticType);
-    Type2 propagatedType = _overrideManager.getType(element2);
+    Type2 propagatedType = _overrideManager.getType(element);
     if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
       recordPropagatedType(node, propagatedType);
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.9: <blockquote>The static type of a rethrow expression is
    * bottom.</blockquote>
    */
@@ skipping 38 matching lines @@
    * <li>If <i>d</i> is the declaration of a top level getter, then <i>e</i> is equivalent to the
    * getter invocation <i>id</i>.
    * <li>Otherwise, if <i>e</i> occurs inside a top level or static function (be it function,
    * method, getter, or setter) or variable initializer, evaluation of e causes a NoSuchMethodError
    * to be thrown.
    * <li>Otherwise <i>e</i> is equivalent to the property extraction <i>this.id</i>.
    * </ul>
    * </blockquote>
    */
   Object visitSimpleIdentifier(SimpleIdentifier node) {
-    Element element2 = node.element;
+    Element element = node.element;
     Type2 staticType = _dynamicType;
-    if (element2 is ClassElement) {
+    if (element is ClassElement) {
       if (isNotTypeLiteral(node)) {
-        staticType = ((element2 as ClassElement)).type;
+        staticType = ((element as ClassElement)).type;
       } else {
         staticType = _typeProvider.typeType;
       }
-    } else if (element2 is FunctionTypeAliasElement) {
-      staticType = ((element2 as FunctionTypeAliasElement)).type;
-    } else if (element2 is MethodElement) {
-      staticType = ((element2 as MethodElement)).type;
-    } else if (element2 is PropertyAccessorElement) {
-      staticType = getType((element2 as PropertyAccessorElement), null);
-    } else if (element2 is ExecutableElement) {
-      staticType = ((element2 as ExecutableElement)).type;
-    } else if (element2 is TypeVariableElement) {
-      staticType = ((element2 as TypeVariableElement)).type;
-    } else if (element2 is VariableElement) {
-      staticType = ((element2 as VariableElement)).type;
-    } else if (element2 is PrefixElement) {
+    } else if (element is FunctionTypeAliasElement) {
+      staticType = ((element as FunctionTypeAliasElement)).type;
+    } else if (element is MethodElement) {
+      staticType = ((element as MethodElement)).type;
+    } else if (element is PropertyAccessorElement) {
+      staticType = getType((element as PropertyAccessorElement), null);
+    } else if (element is ExecutableElement) {
+      staticType = ((element as ExecutableElement)).type;
+    } else if (element is TypeVariableElement) {
+      staticType = ((element as TypeVariableElement)).type;
+    } else if (element is VariableElement) {
+      staticType = ((element as VariableElement)).type;
+    } else if (element is PrefixElement) {
       return null;
     } else {
       staticType = _dynamicType;
     }
     recordStaticType(node, staticType);
-    Type2 propagatedType = _overrideManager.getType(element2);
+    Type2 propagatedType = _overrideManager.getType(element);
     if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
       recordPropagatedType(node, propagatedType);
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.5: <blockquote>The static type of a string literal is{@code String}.</blockquote>
    */
   Object visitSimpleStringLiteral(SimpleStringLiteral node) {
@@ skipping 32 matching lines @@
 
   /**
    * The Dart Language Specification, 12.8: <blockquote>The static type of a throw expression is
    * bottom.</blockquote>
    */
   Object visitThrowExpression(ThrowExpression node) {
     recordStaticType(node, _typeProvider.bottomType);
     return null;
   }
   Object visitVariableDeclaration(VariableDeclaration node) {
-    Expression initializer2 = node.initializer;
-    if (initializer2 != null) {
-      Type2 rightType = getBestType(initializer2);
-      VariableElement element2 = node.name.element as VariableElement;
-      if (element2 != null) {
-        _resolver.override(element2, rightType);
+    Expression initializer = node.initializer;
+    if (initializer != null) {
+      Type2 rightType = getBestType(initializer);
+      VariableElement element = node.name.element as VariableElement;
+      if (element != null) {
+        _resolver.override(element, rightType);
       }
     }
     return null;
   }
 
   /**
    * Record that the static type of the given node is the type of the second argument to the method
    * represented by the given element.
    * @param element the element representing the method invoked by the given node
    */
   Type2 computeArgumentType(ExecutableElement element) {
     if (element != null) {
-      List<ParameterElement> parameters2 = element.parameters;
-      if (parameters2 != null && parameters2.length == 2) {
-        return parameters2[1].type;
+      List<ParameterElement> parameters = element.parameters;
+      if (parameters != null && parameters.length == 2) {
+        return parameters[1].type;
       }
     }
     return _dynamicType;
   }
 
   /**
    * Compute the return type of the method or function represented by the given element.
    * @param element the element representing the method or function invoked by the given node
    * @return the return type that was computed
    */
   Type2 computeReturnType(Element element) {
     if (element is PropertyAccessorElement) {
       FunctionType propertyType = ((element as PropertyAccessorElement)).type;
       if (propertyType != null) {
-        Type2 returnType2 = propertyType.returnType;
-        if (returnType2 is InterfaceType) {
-          if (identical(returnType2, _typeProvider.functionType)) {
+        Type2 returnType = propertyType.returnType;
+        if (returnType is InterfaceType) {
+          if (identical(returnType, _typeProvider.functionType)) {
             return _dynamicType;
           }
-          MethodElement callMethod = ((returnType2 as InterfaceType)).lookUpMethod(ElementResolver.CALL_METHOD_NAME, _resolver.definingLibrary);
+          MethodElement callMethod = ((returnType as InterfaceType)).lookUpMethod(ElementResolver.CALL_METHOD_NAME, _resolver.definingLibrary);
           if (callMethod != null) {
             return callMethod.type.returnType;
           }
-        } else if (returnType2 is FunctionType) {
-          Type2 innerReturnType = ((returnType2 as FunctionType)).returnType;
+        } else if (returnType is FunctionType) {
+          Type2 innerReturnType = ((returnType as FunctionType)).returnType;
           if (innerReturnType != null) {
             return innerReturnType;
           }
-        } else if (returnType2.isDartCoreFunction()) {
+        } else if (returnType.isDartCoreFunction()) {
           return _dynamicType;
         }
-        if (returnType2 != null) {
-          return returnType2;
+        if (returnType != null) {
+          return returnType;
         }
       }
     } else if (element is ExecutableElement) {
-      FunctionType type2 = ((element as ExecutableElement)).type;
-      if (type2 != null) {
-        return type2.returnType;
+      FunctionType type = ((element as ExecutableElement)).type;
+      if (type != null) {
+        return type.returnType;
       }
     } else if (element is VariableElement) {
       Type2 variableType = ((element as VariableElement)).type;
       if (variableType is FunctionType) {
         return ((variableType as FunctionType)).returnType;
       }
     }
     return _dynamicType;
   }
 
   /**
    * Given a function declaration, compute the return type of the function. The return type of
    * functions with a block body is {@code dynamicType}, with an expression body it is the type of
    * the expression.
    * @param node the function expression whose return type is to be computed
    * @return the return type that was computed
    */
   Type2 computeReturnType2(FunctionDeclaration node) {
-    TypeName returnType2 = node.returnType;
-    if (returnType2 == null) {
+    TypeName returnType = node.returnType;
+    if (returnType == null) {
       return _dynamicType;
     }
-    return returnType2.type;
+    return returnType.type;
   }
 
   /**
    * Given a function expression, compute the return type of the function. The return type of
    * functions with a block body is {@code dynamicType}, with an expression body it is the type of
    * the expression.
    * @param node the function expression whose return type is to be computed
    * @return the return type that was computed
    */
   Type2 computeReturnType3(FunctionExpression node) {
-    FunctionBody body2 = node.body;
-    if (body2 is ExpressionFunctionBody) {
-      return getStaticType(((body2 as ExpressionFunctionBody)).expression);
+    FunctionBody body = node.body;
+    if (body is ExpressionFunctionBody) {
+      return getStaticType(((body as ExpressionFunctionBody)).expression);
     }
     return _dynamicType;
   }
 
   /**
    * Return the propagated type of the given expression if it is available, or the static type if
    * there is no propagated type.
    * @param expression the expression whose type is to be returned
    * @return the propagated or static type of the given expression
    */
@@ skipping 36 matching lines @@
     return null;
   }
 
   /**
    * If the given argument list contains at least one argument, and if the argument is a simple
    * string literal, return the String value of the argument.
    * @param argumentList the list of arguments from which a string value is to be extracted
    * @return the string specified by the first argument in the argument list
    */
   String getFirstArgumentAsString(ArgumentList argumentList) {
-    NodeList<Expression> arguments2 = argumentList.arguments;
-    if (arguments2.length > 0) {
-      Expression argument = arguments2[0];
+    NodeList<Expression> arguments = argumentList.arguments;
+    if (arguments.length > 0) {
+      Expression argument = arguments[0];
       if (argument is SimpleStringLiteral) {
         return ((argument as SimpleStringLiteral)).value;
       }
     }
     return null;
   }
 
   /**
    * If the given argument list contains at least one argument, and if the argument is a simple
    * string literal, and if the value of the argument is the name of a class defined within the
@@ skipping 60 matching lines @@
   Type2 getType(PropertyAccessorElement accessor, Type2 context) {
     FunctionType functionType = accessor.type;
     if (functionType == null) {
       return _dynamicType;
     }
     if (accessor.isSetter()) {
       List<Type2> parameterTypes = functionType.normalParameterTypes;
       if (parameterTypes != null && parameterTypes.length > 0) {
         return parameterTypes[0];
       }
-      PropertyAccessorElement getter2 = accessor.variable.getter;
-      if (getter2 != null) {
-        functionType = getter2.type;
+      PropertyAccessorElement getter = accessor.variable.getter;
+      if (getter != null) {
+        functionType = getter.type;
         if (functionType != null) {
           return functionType.returnType;
         }
       }
       return _dynamicType;
     }
-    Type2 returnType2 = functionType.returnType;
-    if (returnType2 is TypeVariableType && context is InterfaceType) {
+    Type2 returnType = functionType.returnType;
+    if (returnType is TypeVariableType && context is InterfaceType) {
       InterfaceType interfaceTypeContext = (context as InterfaceType);
       List<TypeVariableElement> parameterElements = interfaceTypeContext.element != null ? interfaceTypeContext.element.typeVariables : null;
       if (parameterElements != null) {
         for (int i = 0; i < parameterElements.length; i++) {
           TypeVariableElement varElt = parameterElements[i];
-          if (returnType2.name == varElt.name) {
+          if (returnType.name == varElt.name) {
             return interfaceTypeContext.typeArguments[i];
           }
         }
       }
     }
-    return returnType2;
+    return returnType;
   }
 
   /**
    * Return the type represented by the given type name.
    * @param typeName the type name representing the type to be returned
    * @return the type represented by the type name
    */
   Type2 getType2(TypeName typeName) {
-    Type2 type2 = typeName.type;
-    if (type2 == null) {
+    Type2 type = typeName.type;
+    if (type == null) {
       return _dynamicType;
     }
-    return type2;
+    return type;
   }
 
   /**
    * Return {@code true} if the given library is the 'dart:html' library.
    * @param library the library being tested
    * @return {@code true} if the library is 'dart:html'
    */
   bool isHtmlLibrary(LibraryElement library) => library.name == "dart.dom.html";
 
   /**
    * Return {@code true} if the given node is not a type literal.
    * @param node the node being tested
    * @return {@code true} if the given node is not a type literal
    */
   bool isNotTypeLiteral(Identifier node) {
-    ASTNode parent2 = node.parent;
-    return parent2 is TypeName || (parent2 is PrefixedIdentifier && (parent2.parent is TypeName || identical(((parent2 as PrefixedIdentifier)).prefix, node))) || (parent2 is PropertyAccess && identical(((parent2 as PropertyAccess)).target, node)) || (parent2 is MethodInvocation && identical(node, ((parent2 as MethodInvocation)).target));
+    ASTNode parent = node.parent;
+    return parent is TypeName || (parent is PrefixedIdentifier && (parent.parent is TypeName || identical(((parent as PrefixedIdentifier)).prefix, node))) || (parent is PropertyAccess && identical(((parent as PropertyAccess)).target, node)) || (parent is MethodInvocation && identical(node, ((parent as MethodInvocation)).target));
   }
 
   /**
    * Record that the propagated type of the given node is the given type.
    * @param expression the node whose type is to be recorded
    * @param type the propagated type of the node
    */
   void recordPropagatedType(Expression expression, Type2 type) {
     if (type != null && !type.isDynamic()) {
       expression.propagatedType = type;
@@ skipping 13 matching lines @@
     }
   }
 
   /**
    * Attempts to make a better guess for the static type of the given binary expression.
    * @param node the binary expression to analyze
    * @param staticType the static type of the expression as resolved
    * @return the better type guess, or the same static type as given
    */
   Type2 refineBinaryExpressionType(BinaryExpression node, Type2 staticType) {
-    sc.TokenType operator2 = node.operator.type;
-    if (identical(operator2, sc.TokenType.AMPERSAND_AMPERSAND) || identical(operator2, sc.TokenType.BAR_BAR) || identical(operator2, sc.TokenType.EQ_EQ) || identical(operator2, sc.TokenType.BANG_EQ)) {
+    sc.TokenType operator = node.operator.type;
+    if (identical(operator, sc.TokenType.AMPERSAND_AMPERSAND) || identical(operator, sc.TokenType.BAR_BAR) || identical(operator, sc.TokenType.EQ_EQ) || identical(operator, sc.TokenType.BANG_EQ)) {
       return _typeProvider.boolType;
     }
-    if (identical(operator2, sc.TokenType.MINUS) || identical(operator2, sc.TokenType.PERCENT) || identical(operator2, sc.TokenType.PLUS) || identical(operator2, sc.TokenType.STAR)) {
-      Type2 doubleType2 = _typeProvider.doubleType;
-      if (identical(getStaticType(node.leftOperand), doubleType2) || identical(getStaticType(node.rightOperand), doubleType2)) {
-        return doubleType2;
+    if (identical(operator, sc.TokenType.MINUS) || identical(operator, sc.TokenType.PERCENT) || identical(operator, sc.TokenType.PLUS) || identical(operator, sc.TokenType.STAR)) {
+      Type2 doubleType = _typeProvider.doubleType;
+      if (identical(getStaticType(node.leftOperand), doubleType) || identical(getStaticType(node.rightOperand), doubleType)) {
+        return doubleType;
       }
     }
-    if (identical(operator2, sc.TokenType.MINUS) || identical(operator2, sc.TokenType.PERCENT) || identical(operator2, sc.TokenType.PLUS) || identical(operator2, sc.TokenType.STAR) || identical(operator2, sc.TokenType.TILDE_SLASH)) {
-      Type2 intType2 = _typeProvider.intType;
-      if (identical(getStaticType(node.leftOperand), intType2) && identical(getStaticType(node.rightOperand), intType2)) {
-        staticType = intType2;
+    if (identical(operator, sc.TokenType.MINUS) || identical(operator, sc.TokenType.PERCENT) || identical(operator, sc.TokenType.PLUS) || identical(operator, sc.TokenType.STAR) || identical(operator, sc.TokenType.TILDE_SLASH)) {
+      Type2 intType = _typeProvider.intType;
+      if (identical(getStaticType(node.leftOperand), intType) && identical(getStaticType(node.rightOperand), intType)) {
+        staticType = intType;
       }
     }
     return staticType;
   }
 
   /**
    * Set the return type and parameter type information for the given function type based on the
    * given return type and parameter elements.
    * @param functionType the function type to be filled in
    * @param returnType the return type of the function, or {@code null} if no type was declared
@@ skipping 158 matching lines @@
   /**
    * Return a map from the elements for the variables in the given list that have their types
    * overridden to the overriding type.
    * @param variableList the list of variables whose overriding types are to be captured
    * @return a table mapping elements to their overriding types
    */
   Map<Element, Type2> captureOverrides(VariableDeclarationList variableList) {
     Map<Element, Type2> overrides = new Map<Element, Type2>();
     if (variableList.isConst() || variableList.isFinal()) {
       for (VariableDeclaration variable in variableList.variables) {
-        Element element2 = variable.element;
-        if (element2 != null) {
-          Type2 type = _overridenTypes[element2];
+        Element element = variable.element;
+        if (element != null) {
+          Type2 type = _overridenTypes[element];
           if (type != null) {
-            overrides[element2] = type;
+            overrides[element] = type;
           }
         }
       }
     }
     return overrides;
   }
 
   /**
    * Return the overridden type of the given element, or {@code null} if the type of the element
    * has not been overridden.
@@ skipping 289 matching lines @@
     SimpleIdentifier exception = node.exceptionParameter;
     if (exception != null) {
       TypeName exceptionTypeName = node.exceptionType;
       Type2 exceptionType;
       if (exceptionTypeName == null) {
         exceptionType = typeProvider.objectType;
       } else {
         exceptionType = getType3(exceptionTypeName);
       }
       recordType(exception, exceptionType);
-      Element element2 = exception.element;
-      if (element2 is VariableElementImpl) {
-        ((element2 as VariableElementImpl)).type = exceptionType;
+      Element element = exception.element;
+      if (element is VariableElementImpl) {
+        ((element as VariableElementImpl)).type = exceptionType;
       } else {
       }
     }
     SimpleIdentifier stackTrace = node.stackTraceParameter;
     if (stackTrace != null) {
       recordType(stackTrace, typeProvider.stackTraceType);
     }
     return null;
   }
   Object visitClassDeclaration(ClassDeclaration node) {
     _hasReferenceToSuper = false;
     super.visitClassDeclaration(node);
     ClassElementImpl classElement = getClassElement(node.name);
     InterfaceType superclassType = null;
-    ExtendsClause extendsClause2 = node.extendsClause;
-    if (extendsClause2 != null) {
+    ExtendsClause extendsClause = node.extendsClause;
+    if (extendsClause != null) {
       ErrorCode errorCode = node.withClause == null ? CompileTimeErrorCode.EXTENDS_NON_CLASS : CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS;
-      superclassType = resolveType(extendsClause2.superclass, errorCode);
+      superclassType = resolveType(extendsClause.superclass, errorCode);
       if (superclassType != typeProvider.objectType) {
         classElement.validMixin = false;
       }
     }
     if (classElement != null) {
       if (superclassType == null) {
-        InterfaceType objectType2 = typeProvider.objectType;
-        if (classElement.type != objectType2) {
-          superclassType = objectType2;
+        InterfaceType objectType = typeProvider.objectType;
+        if (classElement.type != objectType) {
+          superclassType = objectType;
         }
       }
       classElement.supertype = superclassType;
       classElement.hasReferenceToSuper2 = _hasReferenceToSuper;
     }
     resolve(classElement, node.withClause, node.implementsClause);
     return null;
   }
   Object visitClassTypeAlias(ClassTypeAlias node) {
     super.visitClassTypeAlias(node);
     ClassElementImpl classElement = getClassElement(node.name);
     InterfaceType superclassType = resolveType(node.superclass, CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS);
     if (superclassType == null) {
       superclassType = typeProvider.objectType;
     }
     if (classElement != null && superclassType != null) {
       classElement.supertype = superclassType;
     }
     resolve(classElement, node.withClause, node.implementsClause);
     return null;
   }
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     super.visitConstructorDeclaration(node);
-    ExecutableElementImpl element2 = node.element as ExecutableElementImpl;
-    FunctionTypeImpl type = new FunctionTypeImpl.con1(element2);
-    setTypeInformation(type, null, element2.parameters);
-    type.returnType = ((element2.enclosingElement as ClassElement)).type;
-    element2.type = type;
+    ExecutableElementImpl element = node.element as ExecutableElementImpl;
+    FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
+    setTypeInformation(type, null, element.parameters);
+    type.returnType = ((element.enclosingElement as ClassElement)).type;
+    element.type = type;
     return null;
   }
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     super.visitDeclaredIdentifier(node);
     Type2 declaredType;
     TypeName typeName = node.type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
       declaredType = getType3(typeName);
     }
-    LocalVariableElementImpl element2 = node.element as LocalVariableElementImpl;
-    element2.type = declaredType;
+    LocalVariableElementImpl element = node.element as LocalVariableElementImpl;
+    element.type = declaredType;
     return null;
   }
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     super.visitDefaultFormalParameter(node);
     return null;
   }
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     super.visitFieldFormalParameter(node);
-    Element element2 = node.identifier.element;
-    if (element2 is ParameterElementImpl) {
-      ParameterElementImpl parameter = element2 as ParameterElementImpl;
+    Element element = node.identifier.element;
+    if (element is ParameterElementImpl) {
+      ParameterElementImpl parameter = element as ParameterElementImpl;
       Type2 type;
       TypeName typeName = node.type;
       if (typeName == null) {
         type = _dynamicType;
       } else {
         type = getType3(typeName);
       }
       parameter.type = type;
     } else {
     }
     return null;
   }
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     super.visitFunctionDeclaration(node);
-    ExecutableElementImpl element2 = node.element as ExecutableElementImpl;
-    FunctionTypeImpl type = new FunctionTypeImpl.con1(element2);
-    setTypeInformation(type, node.returnType, element2.parameters);
-    element2.type = type;
+    ExecutableElementImpl element = node.element as ExecutableElementImpl;
+    FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
+    setTypeInformation(type, node.returnType, element.parameters);
+    element.type = type;
     return null;
   }
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     super.visitFunctionTypeAlias(node);
-    FunctionTypeAliasElementImpl element2 = node.element as FunctionTypeAliasElementImpl;
-    FunctionTypeImpl type2 = element2.type as FunctionTypeImpl;
-    setTypeInformation(type2, node.returnType, element2.parameters);
+    FunctionTypeAliasElementImpl element = node.element as FunctionTypeAliasElementImpl;
+    FunctionTypeImpl type = element.type as FunctionTypeImpl;
+    setTypeInformation(type, node.returnType, element.parameters);
     return null;
   }
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     super.visitFunctionTypedFormalParameter(node);
-    ParameterElementImpl element2 = node.identifier.element as ParameterElementImpl;
+    ParameterElementImpl element = node.identifier.element as ParameterElementImpl;
     AnonymousFunctionTypeImpl type = new AnonymousFunctionTypeImpl();
-    List<ParameterElement> parameters2 = getElements(node.parameters);
-    setTypeInformation(type, node.returnType, parameters2);
-    type.baseParameters = parameters2;
-    element2.type = type;
+    List<ParameterElement> parameters = getElements(node.parameters);
+    setTypeInformation(type, node.returnType, parameters);
+    type.baseParameters = parameters;
+    element.type = type;
     return null;
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
     super.visitMethodDeclaration(node);
-    ExecutableElementImpl element2 = node.element as ExecutableElementImpl;
-    FunctionTypeImpl type = new FunctionTypeImpl.con1(element2);
-    setTypeInformation(type, node.returnType, element2.parameters);
-    element2.type = type;
-    if (element2 is PropertyAccessorElement) {
-      PropertyAccessorElement accessor = element2 as PropertyAccessorElement;
-      PropertyInducingElementImpl variable2 = accessor.variable as PropertyInducingElementImpl;
+    ExecutableElementImpl element = node.element as ExecutableElementImpl;
+    FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
+    setTypeInformation(type, node.returnType, element.parameters);
+    element.type = type;
+    if (element is PropertyAccessorElement) {
+      PropertyAccessorElement accessor = element as PropertyAccessorElement;
+      PropertyInducingElementImpl variable = accessor.variable as PropertyInducingElementImpl;
       if (accessor.isGetter()) {
-        variable2.type = type.returnType;
-      } else if (variable2.type == null) {
+        variable.type = type.returnType;
+      } else if (variable.type == null) {
         List<Type2> parameterTypes = type.normalParameterTypes;
         if (parameterTypes != null && parameterTypes.length > 0) {
-          variable2.type = parameterTypes[0];
+          variable.type = parameterTypes[0];
         }
       }
     }
     return null;
   }
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     super.visitSimpleFormalParameter(node);
     Type2 declaredType;
     TypeName typeName = node.type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
       declaredType = getType3(typeName);
     }
-    Element element2 = node.identifier.element;
-    if (element2 is ParameterElement) {
-      ((element2 as ParameterElementImpl)).type = declaredType;
+    Element element = node.identifier.element;
+    if (element is ParameterElement) {
+      ((element as ParameterElementImpl)).type = declaredType;
     } else {
     }
     return null;
   }
   Object visitSuperExpression(SuperExpression node) {
     _hasReferenceToSuper = true;
     return super.visitSuperExpression(node);
   }
   Object visitTypeName(TypeName node) {
     super.visitTypeName(node);
@@ skipping 10 matching lines @@
         return null;
       }
       VoidTypeImpl voidType = VoidTypeImpl.instance;
       if (typeName.name == voidType.name) {
         if (argumentList != null) {
         }
         typeName.staticType = voidType;
         node.type = voidType;
         return null;
       }
-      ASTNode parent2 = node.parent;
-      if (typeName is PrefixedIdentifier && parent2 is ConstructorName && argumentList == null) {
-        ConstructorName name = parent2 as ConstructorName;
+      ASTNode parent = node.parent;
+      if (typeName is PrefixedIdentifier && parent is ConstructorName && argumentList == null) {
+        ConstructorName name = parent as ConstructorName;
         if (name.name == null) {
-          SimpleIdentifier prefix2 = ((typeName as PrefixedIdentifier)).prefix;
-          element = nameScope.lookup(prefix2, definingLibrary);
+          SimpleIdentifier prefix = ((typeName as PrefixedIdentifier)).prefix;
+          element = nameScope.lookup(prefix, definingLibrary);
           if (element is PrefixElement) {
             return null;
           } else if (element != null) {
             name.name = ((typeName as PrefixedIdentifier)).identifier;
             name.period = ((typeName as PrefixedIdentifier)).period;
-            node.name = prefix2;
-            typeName = prefix2;
+            node.name = prefix;
+            typeName = prefix;
           }
         }
       }
     }
     bool elementValid = element is! MultiplyDefinedElement;
     if (elementValid && element is! ClassElement && isTypeNameInInstanceCreationExpression(node)) {
       SimpleIdentifier typeNameSimple = getTypeSimpleIdentifier(typeName);
       InstanceCreationExpression creation = node.parent.parent as InstanceCreationExpression;
       if (creation.isConst()) {
         if (element == null) {
@@ skipping 51 matching lines @@
         node.type = type;
       }
     } else {
       if (isTypeNameInCatchClause(node)) {
         reportError(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName, [typeName.name]);
       } else if (isTypeNameInAsExpression(node)) {
         reportError(StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
       } else if (isTypeNameInIsExpression(node)) {
         reportError(StaticWarningCode.TYPE_TEST_NON_TYPE, typeName, [typeName.name]);
       } else {
-        ASTNode parent3 = typeName.parent;
-        while (parent3 is TypeName) {
-          parent3 = parent3.parent;
+        ASTNode parent = typeName.parent;
+        while (parent is TypeName) {
+          parent = parent.parent;
         }
-        if (parent3 is ExtendsClause || parent3 is ImplementsClause || parent3 is WithClause || parent3 is ClassTypeAlias) {
+        if (parent is ExtendsClause || parent is ImplementsClause || parent is WithClause || parent is ClassTypeAlias) {
         } else {
           reportError(StaticWarningCode.NOT_A_TYPE, typeName, [typeName.name]);
         }
       }
       setElement(typeName, _dynamicType.element);
       typeName.staticType = _dynamicType;
       node.type = _dynamicType;
       return null;
     }
     if (argumentList != null) {
-      NodeList<TypeName> arguments2 = argumentList.arguments;
-      int argumentCount = arguments2.length;
+      NodeList<TypeName> arguments = argumentList.arguments;
+      int argumentCount = arguments.length;
       List<Type2> parameters = getTypeArguments(type);
       int parameterCount = parameters.length;
       int count = Math.min(argumentCount, parameterCount);
       List<Type2> typeArguments = new List<Type2>();
       for (int i = 0; i < count; i++) {
-        Type2 argumentType = getType3(arguments2[i]);
+        Type2 argumentType = getType3(arguments[i]);
         if (argumentType != null) {
           typeArguments.add(argumentType);
         }
       }
       if (argumentCount != parameterCount) {
         reportError(getInvalidTypeParametersErrorCode(node), node, [typeName.name, parameterCount, argumentCount]);
       }
       argumentCount = typeArguments.length;
       if (argumentCount < parameterCount) {
         for (int i = argumentCount; i < parameterCount; i++) {
@@ skipping 26 matching lines @@
   }
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
     Type2 declaredType;
     TypeName typeName = ((node.parent as VariableDeclarationList)).type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
       declaredType = getType3(typeName);
     }
-    Element element2 = node.name.element;
-    if (element2 is VariableElement) {
-      ((element2 as VariableElementImpl)).type = declaredType;
-      if (element2 is PropertyInducingElement) {
-        PropertyInducingElement variableElement = element2 as PropertyInducingElement;
-        PropertyAccessorElementImpl getter2 = variableElement.getter as PropertyAccessorElementImpl;
-        FunctionTypeImpl getterType = new FunctionTypeImpl.con1(getter2);
+    Element element = node.name.element;
+    if (element is VariableElement) {
+      ((element as VariableElementImpl)).type = declaredType;
+      if (element is PropertyInducingElement) {
+        PropertyInducingElement variableElement = element as PropertyInducingElement;
+        PropertyAccessorElementImpl getter = variableElement.getter as PropertyAccessorElementImpl;
+        FunctionTypeImpl getterType = new FunctionTypeImpl.con1(getter);
         getterType.returnType = declaredType;
-        getter2.type = getterType;
-        PropertyAccessorElementImpl setter2 = variableElement.setter as PropertyAccessorElementImpl;
-        if (setter2 != null) {
-          FunctionTypeImpl setterType = new FunctionTypeImpl.con1(setter2);
+        getter.type = getterType;
+        PropertyAccessorElementImpl setter = variableElement.setter as PropertyAccessorElementImpl;
+        if (setter != null) {
+          FunctionTypeImpl setterType = new FunctionTypeImpl.con1(setter);
           setterType.returnType = VoidTypeImpl.instance;
           setterType.normalParameterTypes = <Type2> [declaredType];
-          setter2.type = setterType;
+          setter.type = setterType;
         }
       }
     } else {
     }
     return null;
   }
 
   /**
    * Return the class element that represents the class whose name was provided.
    * @param identifier the name from the declaration of a class
    * @return the class element that represents the class
    */
   ClassElementImpl getClassElement(SimpleIdentifier identifier) {
     if (identifier == null) {
       return null;
     }
-    Element element2 = identifier.element;
-    if (element2 is! ClassElementImpl) {
+    Element element = identifier.element;
+    if (element is! ClassElementImpl) {
       return null;
     }
-    return element2 as ClassElementImpl;
+    return element as ClassElementImpl;
   }
 
   /**
    * Return an array containing all of the elements associated with the parameters in the given
    * list.
    * @param parameterList the list of parameters whose elements are to be returned
    * @return the elements associated with the parameters
    */
   List<ParameterElement> getElements(FormalParameterList parameterList) {
     List<ParameterElement> elements = new List<ParameterElement>();
     for (FormalParameter parameter in parameterList.parameters) {
-      ParameterElement element2 = parameter.identifier.element as ParameterElement;
-      if (element2 != null) {
-        elements.add(element2);
+      ParameterElement element = parameter.identifier.element as ParameterElement;
+      if (element != null) {
+        elements.add(element);
       }
     }
     return new List.from(elements);
   }
 
   /**
    * The number of type arguments in the given type name does not match the number of parameters in
    * the corresponding class element. Return the error code that should be used to report this
    * error.
    * @param node the type name with the wrong number of type arguments
    * @return the error code that should be used to report that the wrong number of type arguments
    * were provided
    */
   ErrorCode getInvalidTypeParametersErrorCode(TypeName node) {
-    ASTNode parent2 = node.parent;
-    if (parent2 is ConstructorName) {
-      parent2 = parent2.parent;
-      if (parent2 is InstanceCreationExpression) {
-        if (((parent2 as InstanceCreationExpression)).isConst()) {
+    ASTNode parent = node.parent;
+    if (parent is ConstructorName) {
+      parent = parent.parent;
+      if (parent is InstanceCreationExpression) {
+        if (((parent as InstanceCreationExpression)).isConst()) {
           return CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS;
         } else {
           return CompileTimeErrorCode.NEW_WITH_INVALID_TYPE_PARAMETERS;
         }
       }
     }
     return StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS;
   }
 
   /**
@@ skipping 14 matching lines @@
     }
     return type;
   }
 
   /**
    * Return the type represented by the given type name.
    * @param typeName the type name representing the type to be returned
    * @return the type represented by the type name
    */
   Type2 getType3(TypeName typeName) {
-    Type2 type2 = typeName.type;
-    if (type2 == null) {
+    Type2 type = typeName.type;
+    if (type == null) {
       return _dynamicType;
     }
-    return type2;
+    return type;
   }
 
   /**
    * Return the type arguments associated with the given type.
    * @param type the type whole type arguments are to be returned
    * @return the type arguments associated with the given type
    */
   List<Type2> getTypeArguments(Type2 type) {
     if (type is InterfaceType) {
       return ((type as InterfaceType)).typeArguments;
@@ skipping 15 matching lines @@
       return ((typeName as PrefixedIdentifier)).identifier;
     }
   }
 
   /**
    * Checks if the given type name is used as the type in an as expression.
    * @param typeName the type name to analyzer
    * @return {@code true} if the given type name is used as the type in an as expression
    */
   bool isTypeNameInAsExpression(TypeName typeName) {
-    ASTNode parent2 = typeName.parent;
-    if (parent2 is AsExpression) {
-      AsExpression asExpression = parent2 as AsExpression;
+    ASTNode parent = typeName.parent;
+    if (parent is AsExpression) {
+      AsExpression asExpression = parent as AsExpression;
       return identical(asExpression.type, typeName);
     }
     return false;
   }
 
   /**
    * Checks if the given type name is used as the exception type in a catch clause.
    * @param typeName the type name to analyzer
    * @return {@code true} if the given type name is used as the exception type in a catch clause
    */
   bool isTypeNameInCatchClause(TypeName typeName) {
-    ASTNode parent2 = typeName.parent;
-    if (parent2 is CatchClause) {
-      CatchClause catchClause = parent2 as CatchClause;
+    ASTNode parent = typeName.parent;
+    if (parent is CatchClause) {
+      CatchClause catchClause = parent as CatchClause;
       return identical(catchClause.exceptionType, typeName);
     }
     return false;
   }
 
   /**
    * Checks if the given type name is used as the type in an instance creation expression.
    * @param typeName the type name to analyzer
    * @return {@code true} if the given type name is used as the type in an instance creation
    * expression
    */
   bool isTypeNameInInstanceCreationExpression(TypeName typeName) {
-    ASTNode parent2 = typeName.parent;
-    if (parent2 is ConstructorName && parent2.parent is InstanceCreationExpression) {
-      ConstructorName constructorName = parent2 as ConstructorName;
+    ASTNode parent = typeName.parent;
+    if (parent is ConstructorName && parent.parent is InstanceCreationExpression) {
+      ConstructorName constructorName = parent as ConstructorName;
       return constructorName != null && identical(constructorName.type, typeName);
     }
     return false;
   }
 
   /**
    * Checks if the given type name is used as the type in an is expression.
    * @param typeName the type name to analyzer
    * @return {@code true} if the given type name is used as the type in an is expression
    */
   bool isTypeNameInIsExpression(TypeName typeName) {
-    ASTNode parent2 = typeName.parent;
-    if (parent2 is IsExpression) {
-      IsExpression isExpression = parent2 as IsExpression;
+    ASTNode parent = typeName.parent;
+    if (parent is IsExpression) {
+      IsExpression isExpression = parent as IsExpression;
       return identical(isExpression.type, typeName);
     }
     return false;
   }
 
   /**
    * Checks if the given type name is the target in a redirected constructor.
    * @param typeName the type name to analyzer
    * @return {@code true} if the given type name is used as the type in a redirected constructor
    */
   bool isTypeNameTargetInRedirectedConstructor(TypeName typeName) {
-    ASTNode parent2 = typeName.parent;
-    if (parent2 is ConstructorName) {
-      ConstructorName constructorName = parent2 as ConstructorName;
-      parent2 = constructorName.parent;
-      if (parent2 is ConstructorDeclaration) {
-        ConstructorDeclaration constructorDeclaration = parent2 as ConstructorDeclaration;
+    ASTNode parent = typeName.parent;
+    if (parent is ConstructorName) {
+      ConstructorName constructorName = parent as ConstructorName;
+      parent = constructorName.parent;
+      if (parent is ConstructorDeclaration) {
+        ConstructorDeclaration constructorDeclaration = parent as ConstructorDeclaration;
         return constructorName == constructorDeclaration.redirectedConstructor;
       }
     }
     return false;
   }
 
   /**
    * Record that the static type of the given node is the given type.
    * @param expression the node whose type is to be recorded
    * @param type the static type of the node
@@ skipping 10 matching lines @@
   /**
    * Resolve the types in the given with and implements clauses and associate those types with the
    * given class element.
    * @param classElement the class element with which the mixin and interface types are to be
    * associated
    * @param withClause the with clause to be resolved
    * @param implementsClause the implements clause to be resolved
    */
   void resolve(ClassElementImpl classElement, WithClause withClause, ImplementsClause implementsClause) {
     if (withClause != null) {
-      List<InterfaceType> mixinTypes2 = resolveTypes(withClause.mixinTypes, CompileTimeErrorCode.MIXIN_OF_NON_CLASS);
+      List<InterfaceType> mixinTypes = resolveTypes(withClause.mixinTypes, CompileTimeErrorCode.MIXIN_OF_NON_CLASS);
       if (classElement != null) {
-        classElement.mixins = mixinTypes2;
+        classElement.mixins = mixinTypes;
       }
     }
     if (implementsClause != null) {
-      NodeList<TypeName> interfaces2 = implementsClause.interfaces;
-      List<InterfaceType> interfaceTypes = resolveTypes(interfaces2, CompileTimeErrorCode.IMPLEMENTS_NON_CLASS);
-      List<TypeName> typeNames = new List.from(interfaces2);
+      NodeList<TypeName> interfaces = implementsClause.interfaces;
+      List<InterfaceType> interfaceTypes = resolveTypes(interfaces, CompileTimeErrorCode.IMPLEMENTS_NON_CLASS);
+      List<TypeName> typeNames = new List.from(interfaces);
       String dynamicKeyword = sc.Keyword.DYNAMIC.syntax;
       List<bool> detectedRepeatOnIndex = new List<bool>.filled(typeNames.length, false);
       for (int i = 0; i < detectedRepeatOnIndex.length; i++) {
         detectedRepeatOnIndex[i] = false;
       }
       for (int i = 0; i < typeNames.length; i++) {
         TypeName typeName = typeNames[i];
-        String name3 = typeName.name.name;
-        if (name3 == dynamicKeyword) {
+        String name = typeName.name.name;
+        if (name == dynamicKeyword) {
           reportError(CompileTimeErrorCode.IMPLEMENTS_DYNAMIC, typeName, []);
         }
         if (!detectedRepeatOnIndex[i]) {
           for (int j = i + 1; j < typeNames.length; j++) {
-            Element element3 = typeName.name.element;
+            Element element = typeName.name.element;
             TypeName typeName2 = typeNames[j];
             Identifier identifier2 = typeName2.name;
             String name2 = identifier2.name;
             Element element2 = identifier2.element;
-            if (element3 != null && element3 == element2) {
+            if (element != null && element == element2) {
               detectedRepeatOnIndex[j] = true;
               reportError(CompileTimeErrorCode.IMPLEMENTS_REPEATED, typeName2, [name2]);
             }
           }
         }
       }
       if (classElement != null) {
         classElement.interfaces = interfaceTypes;
       }
     }
   }
 
   /**
    * Return the type specified by the given name.
    * @param typeName the type name specifying the type to be returned
    * @param nonTypeError the error to produce if the type name is defined to be something other than
    * a type
    * @return the type specified by the type name
    */
   InterfaceType resolveType(TypeName typeName, ErrorCode nonTypeError) {
-    Type2 type2 = typeName.type;
-    if (type2 is InterfaceType) {
-      return type2 as InterfaceType;
+    Type2 type = typeName.type;
+    if (type is InterfaceType) {
+      return type as InterfaceType;
     }
-    Identifier name2 = typeName.name;
-    if (name2.name != sc.Keyword.DYNAMIC.syntax) {
-      reportError(nonTypeError, name2, [name2.name]);
+    Identifier name = typeName.name;
+    if (name.name != sc.Keyword.DYNAMIC.syntax) {
+      reportError(nonTypeError, name, [name.name]);
     }
     return null;
   }
 
   /**
    * Resolve the types in the given list of type names.
    * @param typeNames the type names to be resolved
    * @param nonTypeError the error to produce if the type name is defined to be something other than
    * a type
    * @return an array containing all of the types that were resolved.
@@ skipping 10 matching lines @@
   }
   void setElement(Identifier typeName, Element element2) {
     if (element2 != null) {
       if (typeName is SimpleIdentifier) {
         ((typeName as SimpleIdentifier)).staticElement = element2;
         ((typeName as SimpleIdentifier)).element = element2;
       } else if (typeName is PrefixedIdentifier) {
         PrefixedIdentifier identifier = typeName as PrefixedIdentifier;
         identifier.identifier.staticElement = element2;
         identifier.identifier.element = element2;
-        SimpleIdentifier prefix2 = identifier.prefix;
-        Element prefixElement = nameScope.lookup(prefix2, definingLibrary);
+        SimpleIdentifier prefix = identifier.prefix;
+        Element prefixElement = nameScope.lookup(prefix, definingLibrary);
         if (prefixElement != null) {
-          prefix2.staticElement = prefixElement;
-          prefix2.element = prefixElement;
+          prefix.staticElement = prefixElement;
+          prefix.element = prefixElement;
         }
       }
     }
   }
 
   /**
    * Set the return type and parameter type information for the given function type based on the
    * given return type and parameter elements.
    * @param functionType the function type to be filled in
    * @param returnType the return type of the function, or {@code null} if no type was declared
@@ skipping 131 matching lines @@
     defineParameters(functionElement);
   }
 
   /**
    * Define the parameters for the given function in the scope that encloses this function.
    * @param functionElement the element representing the function represented by this scope
    */
   void defineParameters(ExecutableElement functionElement) {
     Scope parameterScope = enclosingScope;
     if (functionElement.enclosingElement is ExecutableElement) {
-      String name2 = functionElement.name;
-      if (name2 != null && !name2.isEmpty) {
+      String name = functionElement.name;
+      if (name != null && !name.isEmpty) {
         parameterScope.define(functionElement);
       }
     }
     for (ParameterElement parameter in functionElement.parameters) {
       if (!parameter.isInitializingFormal()) {
         parameterScope.define(parameter);
       }
     }
   }
 }
@@ skipping 122 matching lines @@
  * Instances of the class {@code LibraryImportScope} represent the scope containing all of the names
  * available from imported libraries.
  * @coverage dart.engine.resolver
  */
 class LibraryImportScope extends Scope {
 
   /**
    * @return {@code true} if the given {@link Identifier} is the part of type annotation.
    */
   static bool isTypeAnnotation(Identifier identifier) {
-    ASTNode parent4 = identifier.parent;
-    if (parent4 is TypeName) {
-      ASTNode parent2 = parent4.parent;
+    ASTNode parent = identifier.parent;
+    if (parent is TypeName) {
+      ASTNode parent2 = parent.parent;
       if (parent2 is FunctionDeclaration) {
         FunctionDeclaration decl = parent2 as FunctionDeclaration;
-        return identical(decl.returnType, parent4);
+        return identical(decl.returnType, parent);
       }
       if (parent2 is FunctionTypeAlias) {
         FunctionTypeAlias decl = parent2 as FunctionTypeAlias;
-        return identical(decl.returnType, parent4);
+        return identical(decl.returnType, parent);
       }
       if (parent2 is MethodDeclaration) {
         MethodDeclaration decl = parent2 as MethodDeclaration;
-        return identical(decl.returnType, parent4);
+        return identical(decl.returnType, parent);
       }
       if (parent2 is VariableDeclarationList) {
         VariableDeclarationList decl = parent2 as VariableDeclarationList;
-        return identical(decl.type, parent4);
+        return identical(decl.type, parent);
       }
       if (parent2 is SimpleFormalParameter) {
         SimpleFormalParameter decl = parent2 as SimpleFormalParameter;
-        return identical(decl.type, parent4);
+        return identical(decl.type, parent);
       }
       if (parent2 is TypeParameter) {
         TypeParameter decl = parent2 as TypeParameter;
-        return identical(decl.bound, parent4);
+        return identical(decl.bound, parent);
       }
       if (parent2 is TypeArgumentList) {
         ASTNode parent3 = parent2.parent;
         if (parent3 is TypeName) {
           TypeName typeName = parent3 as TypeName;
           if (identical((typeName).typeArguments, parent2)) {
             return isTypeAnnotation(typeName.name);
           }
         }
       }
@@ skipping 198 matching lines @@
  * @coverage dart.engine.resolver
  */
 class NamespaceBuilder {
 
   /**
    * Create a namespace representing the export namespace of the given {@link ExportElement}.
    * @param element the export element whose export namespace is to be created
    * @return the export namespace that was created
    */
   Namespace createExportNamespace(ExportElement element) {
-    LibraryElement exportedLibrary2 = element.exportedLibrary;
-    if (exportedLibrary2 == null) {
+    LibraryElement exportedLibrary = element.exportedLibrary;
+    if (exportedLibrary == null) {
       return Namespace.EMPTY;
     }
-    Map<String, Element> definedNames = createExportMapping(exportedLibrary2, new Set<LibraryElement>());
+    Map<String, Element> definedNames = createExportMapping(exportedLibrary, new Set<LibraryElement>());
     definedNames = apply(definedNames, element.combinators);
     return new Namespace(definedNames);
   }
 
   /**
    * Create a namespace representing the export namespace of the given library.
    * @param library the library whose export namespace is to be created
    * @return the export namespace that was created
    */
   Namespace createExportNamespace2(LibraryElement library) => new Namespace(createExportMapping(library, new Set<LibraryElement>()));
 
   /**
    * Create a namespace representing the import namespace of the given library.
    * @param library the library whose import namespace is to be created
    * @return the import namespace that was created
    */
   Namespace createImportNamespace(ImportElement element) {
-    LibraryElement importedLibrary2 = element.importedLibrary;
-    if (importedLibrary2 == null) {
+    LibraryElement importedLibrary = element.importedLibrary;
+    if (importedLibrary == null) {
       return Namespace.EMPTY;
     }
-    Map<String, Element> definedNames = createExportMapping(importedLibrary2, new Set<LibraryElement>());
+    Map<String, Element> definedNames = createExportMapping(importedLibrary, new Set<LibraryElement>());
     definedNames = apply(definedNames, element.combinators);
     definedNames = apply2(definedNames, element.prefix);
     return new Namespace(definedNames);
   }
 
   /**
    * Create a namespace representing the public namespace of the given library.
    * @param library the library whose public namespace is to be created
    * @return the public namespace that was created
    */
@@ skipping 27 matching lines @@
       addAll(definedNames2, namespace.definedNames);
     }
   }
 
   /**
    * Add the given element to the given mapping table if it has a publicly visible name.
    * @param definedNames the mapping table to which the public name is to be added
    * @param element the element to be added
    */
   void addIfPublic(Map<String, Element> definedNames, Element element) {
-    String name2 = element.name;
-    if (name2 != null && !Scope.isPrivateName(name2)) {
-      definedNames[name2] = element;
+    String name = element.name;
+    if (name != null && !Scope.isPrivateName(name)) {
+      definedNames[name] = element;
     }
   }
 
   /**
    * Add to the given mapping table all of the public top-level names that are defined in the given
    * compilation unit.
    * @param definedNames the mapping table to which the public names are to be added
    * @param compilationUnit the compilation unit defining the top-level names to be added to this
    * namespace
    */
@@ skipping 54 matching lines @@
    * @param visitedElements a set of libraries that do not need to be visited when processing the
    * export directives of the given library because all of the names defined by them will
    * be added by another library
    * @return the mapping table that was created
    */
   Map<String, Element> createExportMapping(LibraryElement library, Set<LibraryElement> visitedElements) {
     javaSetAdd(visitedElements, library);
     try {
       Map<String, Element> definedNames = new Map<String, Element>();
       for (ExportElement element in library.exports) {
-        LibraryElement exportedLibrary2 = element.exportedLibrary;
-        if (exportedLibrary2 != null && !visitedElements.contains(exportedLibrary2)) {
-          Map<String, Element> exportedNames = createExportMapping(exportedLibrary2, visitedElements);
+        LibraryElement exportedLibrary = element.exportedLibrary;
+        if (exportedLibrary != null && !visitedElements.contains(exportedLibrary)) {
+          Map<String, Element> exportedNames = createExportMapping(exportedLibrary, visitedElements);
           exportedNames = apply(exportedNames, element.combinators);
           addAll(definedNames, exportedNames);
         }
       }
       addAll2(definedNames, ((library.context as InternalAnalysisContext)).getPublicNamespace(library));
       return definedNames;
     } finally {
       visitedElements.remove(library);
     }
   }
@@ skipping 121 matching lines @@
   LibraryElement get definingLibrary;
 
   /**
    * Return the error code to be used when reporting that a name being defined locally conflicts
    * with another element of the same name in the local scope.
    * @param existing the first element to be declared with the conflicting name
    * @param duplicate another element declared with the conflicting name
    * @return the error code used to report duplicate names within a scope
    */
   AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
-    Source source2 = duplicate.source;
-    if (source2 == null) {
-      source2 = source;
+    Source source = duplicate.source;
+    if (source == null) {
+      source = source;
     }
-    return new AnalysisError.con2(source2, duplicate.nameOffset, duplicate.displayName.length, CompileTimeErrorCode.DUPLICATE_DEFINITION, [existing.displayName]);
+    return new AnalysisError.con2(source, duplicate.nameOffset, duplicate.displayName.length, CompileTimeErrorCode.DUPLICATE_DEFINITION, [existing.displayName]);
   }
 
   /**
    * Return the listener that is to be informed when an error is encountered.
    * @return the listener that is to be informed when an error is encountered
    */
   AnalysisErrorListener get errorListener;
 
   /**
    * Return the source object representing the compilation unit with which errors related to this
@@ skipping 108 matching lines @@
     }
     return null;
   }
   Object visitMapLiteral(MapLiteral node) {
     super.visitMapLiteral(node);
     bool isConst = node.modifier != null;
     bool reportEqualKeys = true;
     Set<Object> keys = new Set<Object>();
     List<Expression> invalidKeys = new List<Expression>();
     for (MapLiteralEntry entry in node.entries) {
-      Expression key2 = entry.key;
+      Expression key = entry.key;
       if (isConst) {
-        EvaluationResultImpl result = validate(key2, CompileTimeErrorCode.NON_CONSTANT_MAP_KEY);
+        EvaluationResultImpl result = validate(key, CompileTimeErrorCode.NON_CONSTANT_MAP_KEY);
         validate(entry.value, CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE);
         if (result is ValidResult) {
-          Object value2 = ((result as ValidResult)).value;
-          if (keys.contains(value2)) {
-            invalidKeys.add(key2);
+          Object value = ((result as ValidResult)).value;
+          if (keys.contains(value)) {
+            invalidKeys.add(key);
           } else {
-            javaSetAdd(keys, value2);
+            javaSetAdd(keys, value);
           }
         }
       } else {
-        EvaluationResultImpl result = key2.accept(new ConstantVisitor());
+        EvaluationResultImpl result = key.accept(new ConstantVisitor());
         if (result is ValidResult) {
-          Object value3 = ((result as ValidResult)).value;
-          if (keys.contains(value3)) {
-            invalidKeys.add(key2);
+          Object value = ((result as ValidResult)).value;
+          if (keys.contains(value)) {
+            invalidKeys.add(key);
           } else {
-            javaSetAdd(keys, value3);
+            javaSetAdd(keys, value);
           }
         } else {
           reportEqualKeys = false;
         }
       }
     }
     if (reportEqualKeys) {
       for (Expression key in invalidKeys) {
         _errorReporter.reportError2(StaticWarningCode.EQUAL_KEYS_IN_MAP, key, []);
       }
     }
     return null;
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
     super.visitMethodDeclaration(node);
     validateDefaultValues(node.parameters);
     return null;
   }
   Object visitSwitchCase(SwitchCase node) {
     super.visitSwitchCase(node);
     validate(node.expression, CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION);
     return null;
   }
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
-    Expression initializer2 = node.initializer;
-    if (initializer2 != null && node.isConst()) {
-      VariableElementImpl element2 = node.element as VariableElementImpl;
-      EvaluationResultImpl result = element2.evaluationResult;
+    Expression initializer = node.initializer;
+    if (initializer != null && node.isConst()) {
+      VariableElementImpl element = node.element as VariableElementImpl;
+      EvaluationResultImpl result = element.evaluationResult;
       if (result == null) {
-        result = validate(initializer2, CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
-        element2.evaluationResult = result;
+        result = validate(initializer, CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
+        element.evaluationResult = result;
       } else if (result is ErrorResult) {
         reportErrors(result, CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
       }
     }
     return null;
   }
 
   /**
    * Return {@code true} if the given value is the result of evaluating an expression whose value is
    * a valid key in a const map literal. Keys in const map literals must be either a string, number,
@@ skipping 37 matching lines @@
 
   /**
    * Validate that if the passed instance creation is 'const' then all its arguments are constant
    * expressions.
    * @param node the instance creation evaluate
    */
   void validateConstantArguments(InstanceCreationExpression node) {
     if (!node.isConst()) {
       return;
     }
-    ArgumentList argumentList2 = node.argumentList;
-    if (argumentList2 == null) {
+    ArgumentList argumentList = node.argumentList;
+    if (argumentList == null) {
       return;
     }
-    for (Expression argument in argumentList2.arguments) {
+    for (Expression argument in argumentList.arguments) {
       if (argument is NamedExpression) {
         argument = ((argument as NamedExpression)).expression;
       }
       validate(argument, CompileTimeErrorCode.CONST_WITH_NON_CONSTANT_ARGUMENT);
     }
   }
 
   /**
    * Validate that the default value associated with each of the parameters in the given list is a
    * compile time constant.
    * @param parameters the list of parameters to be validated
    */
   void validateDefaultValues(FormalParameterList parameters2) {
     if (parameters2 == null) {
       return;
     }
     for (FormalParameter parameter in parameters2.parameters) {
       if (parameter is DefaultFormalParameter) {
         DefaultFormalParameter defaultParameter = parameter as DefaultFormalParameter;
-        Expression defaultValue2 = defaultParameter.defaultValue;
-        if (defaultValue2 != null) {
-          EvaluationResultImpl result = validate(defaultValue2, CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE);
+        Expression defaultValue = defaultParameter.defaultValue;
+        if (defaultValue != null) {
+          EvaluationResultImpl result = validate(defaultValue, CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE);
           if (defaultParameter.isConst()) {
-            VariableElementImpl element2 = parameter.element as VariableElementImpl;
-            element2.evaluationResult = result;
+            VariableElementImpl element = parameter.element as VariableElementImpl;
+            element.evaluationResult = result;
           }
         }
       }
     }
   }
 
   /**
    * Validates that the given expression is a compile time constant.
    * @param parameterElements the elements of parameters of constant constructor, they are
    * considered as a valid potentially constant expressions
@@ skipping 19 matching lines @@
     }
   }
 
   /**
    * Validates that the expressions of the given initializers (of a constant constructor) are all
    * compile time constants.
    * @param constructor the constant constructor declaration to validate
    */
   void validateInitializers(ConstructorDeclaration constructor) {
     List<ParameterElement> parameterElements = constructor.parameters.elements;
-    NodeList<ConstructorInitializer> initializers2 = constructor.initializers;
-    for (ConstructorInitializer initializer in initializers2) {
+    NodeList<ConstructorInitializer> initializers = constructor.initializers;
+    for (ConstructorInitializer initializer in initializers) {
       if (initializer is ConstructorFieldInitializer) {
         ConstructorFieldInitializer fieldInitializer = initializer as ConstructorFieldInitializer;
         validateInitializerExpression(parameterElements, fieldInitializer.expression);
       }
       if (initializer is RedirectingConstructorInvocation) {
         RedirectingConstructorInvocation invocation = initializer as RedirectingConstructorInvocation;
         validateInitializerInvocationArguments(parameterElements, invocation.argumentList);
       }
       if (initializer is SuperConstructorInvocation) {
         SuperConstructorInvocation invocation = initializer as SuperConstructorInvocation;
         validateInitializerInvocationArguments(parameterElements, invocation.argumentList);
       }
     }
   }
 }
 class ConstantVisitor_10 extends ConstantVisitor {
   final ConstantVerifier ConstantVerifier_this;
   List<ParameterElement> parameterElements;
   ConstantVisitor_10(this.ConstantVerifier_this, this.parameterElements) : super();
   EvaluationResultImpl visitSimpleIdentifier(SimpleIdentifier node) {
-    Element element2 = node.element;
+    Element element = node.element;
     for (ParameterElement parameterElement in parameterElements) {
-      if (identical(parameterElement, element2) && parameterElement != null) {
-        Type2 type2 = parameterElement.type;
-        if (type2 != null) {
-          if (type2.isDynamic()) {
+      if (identical(parameterElement, element) && parameterElement != null) {
+        Type2 type = parameterElement.type;
+        if (type != null) {
+          if (type.isDynamic()) {
             return ValidResult.RESULT_DYNAMIC;
           }
-          if (type2.isSubtypeOf(ConstantVerifier_this._boolType)) {
+          if (type.isSubtypeOf(ConstantVerifier_this._boolType)) {
             return ValidResult.RESULT_BOOL;
           }
-          if (type2.isSubtypeOf(ConstantVerifier_this._intType)) {
+          if (type.isSubtypeOf(ConstantVerifier_this._intType)) {
             return ValidResult.RESULT_INT;
           }
-          if (type2.isSubtypeOf(ConstantVerifier_this._numType)) {
+          if (type.isSubtypeOf(ConstantVerifier_this._numType)) {
             return ValidResult.RESULT_NUM;
           }
-          if (type2.isSubtypeOf(ConstantVerifier_this._stringType)) {
+          if (type.isSubtypeOf(ConstantVerifier_this._stringType)) {
             return ValidResult.RESULT_STRING;
           }
         }
         return ValidResult.RESULT_OBJECT;
       }
     }
     return super.visitSimpleIdentifier(node);
   }
 }
 /**
@@ skipping 136 matching lines @@
   }
   Object visitArgumentList(ArgumentList node) {
     checkForArgumentTypeNotAssignable(node);
     return super.visitArgumentList(node);
   }
   Object visitAssertStatement(AssertStatement node) {
     checkForNonBoolExpression(node);
     return super.visitAssertStatement(node);
   }
   Object visitAssignmentExpression(AssignmentExpression node) {
-    sc.Token operator2 = node.operator;
-    sc.TokenType operatorType = operator2.type;
+    sc.Token operator = node.operator;
+    sc.TokenType operatorType = operator.type;
     if (identical(operatorType, sc.TokenType.EQ)) {
       checkForInvalidAssignment2(node.leftHandSide, node.rightHandSide);
     } else {
       checkForInvalidAssignment(node);
     }
     checkForAssignmentToFinal(node);
     return super.visitAssignmentExpression(node);
   }
   Object visitBinaryExpression(BinaryExpression node) {
     checkForArgumentTypeNotAssignable2(node.rightOperand);
     return super.visitBinaryExpression(node);
   }
   Object visitCatchClause(CatchClause node) {
     bool previousIsInCatchClause = _isInCatchClause;
     try {
       _isInCatchClause = true;
       return super.visitCatchClause(node);
     } finally {
       _isInCatchClause = previousIsInCatchClause;
     }
   }
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement outerClass = _enclosingClass;
     try {
       _enclosingClass = node.element;
-      WithClause withClause2 = node.withClause;
-      ImplementsClause implementsClause2 = node.implementsClause;
-      ExtendsClause extendsClause2 = node.extendsClause;
+      WithClause withClause = node.withClause;
+      ImplementsClause implementsClause = node.implementsClause;
+      ExtendsClause extendsClause = node.extendsClause;
       checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME);
       checkForMemberWithClassName();
-      checkForAllMixinErrorCodes(withClause2);
-      if (implementsClause2 != null || extendsClause2 != null) {
-        if (!checkForImplementsDisallowedClass(implementsClause2) && !checkForExtendsDisallowedClass(extendsClause2)) {
+      checkForAllMixinErrorCodes(withClause);
+      if (implementsClause != null || extendsClause != null) {
+        if (!checkForImplementsDisallowedClass(implementsClause) && !checkForExtendsDisallowedClass(extendsClause)) {
           checkForNonAbstractClassInheritsAbstractMember(node);
           checkForInconsistentMethodInheritance();
           checkForRecursiveInterfaceInheritance(_enclosingClass, new List<ClassElement>());
         }
       }
       ClassElement classElement = node.element;
       if (classElement != null) {
         List<FieldElement> fieldElements = classElement.fields;
         _initialFieldElementsMap = new Map<FieldElement, INIT_STATE>();
         for (FieldElement fieldElement in fieldElements) {
@@ skipping 88 matching lines @@
     try {
       SimpleIdentifier identifier = node.name;
       String methoName = "";
       if (identifier != null) {
         methoName = identifier.name;
       }
       _enclosingFunction = node.element;
       if (node.isSetter() || node.isGetter()) {
         checkForMismatchedAccessorTypes(node, methoName);
         if (node.isSetter()) {
-          FunctionExpression functionExpression2 = node.functionExpression;
-          if (functionExpression2 != null) {
-            checkForWrongNumberOfParametersForSetter(node.name, functionExpression2.parameters);
+          FunctionExpression functionExpression = node.functionExpression;
+          if (functionExpression != null) {
+            checkForWrongNumberOfParametersForSetter(node.name, functionExpression.parameters);
           }
-          TypeName returnType2 = node.returnType;
-          checkForNonVoidReturnTypeForSetter(returnType2);
+          TypeName returnType = node.returnType;
+          checkForNonVoidReturnTypeForSetter(returnType);
         }
       }
       return super.visitFunctionDeclaration(node);
     } finally {
       _enclosingFunction = outerFunction;
     }
   }
   Object visitFunctionExpression(FunctionExpression node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
@@ skipping 15 matching lines @@
   Object visitImportDirective(ImportDirective node) {
     checkForImportDuplicateLibraryName(node);
     checkForImportInternalLibrary(node);
     return super.visitImportDirective(node);
   }
   Object visitIndexExpression(IndexExpression node) {
     checkForArgumentTypeNotAssignable2(node.index);
     return super.visitIndexExpression(node);
   }
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
-    ConstructorName constructorName2 = node.constructorName;
-    TypeName typeName = constructorName2.type;
-    Type2 type2 = typeName.type;
-    if (type2 is InterfaceType) {
-      InterfaceType interfaceType = type2 as InterfaceType;
+    ConstructorName constructorName = node.constructorName;
+    TypeName typeName = constructorName.type;
+    Type2 type = typeName.type;
+    if (type is InterfaceType) {
+      InterfaceType interfaceType = type as InterfaceType;
       checkForConstOrNewWithAbstractClass(node, typeName, interfaceType);
       if (node.isConst()) {
         checkForConstWithNonConst(node);
         checkForConstWithUndefinedConstructor(node);
         checkForConstWithTypeParameters(node);
       } else {
         checkForNewWithUndefinedConstructor(node);
       }
-      checkForTypeArgumentNotMatchingBounds(node, constructorName2.element, typeName);
+      checkForTypeArgumentNotMatchingBounds(node, constructorName.element, typeName);
     }
     return super.visitInstanceCreationExpression(node);
   }
   Object visitListLiteral(ListLiteral node) {
     if (node.modifier != null) {
-      TypeArgumentList typeArguments2 = node.typeArguments;
-      if (typeArguments2 != null) {
-        NodeList<TypeName> arguments2 = typeArguments2.arguments;
-        if (arguments2.length != 0) {
-          checkForInvalidTypeArgumentInConstTypedLiteral(arguments2, CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_LIST);
+      TypeArgumentList typeArguments = node.typeArguments;
+      if (typeArguments != null) {
+        NodeList<TypeName> arguments = typeArguments.arguments;
+        if (arguments.length != 0) {
+          checkForInvalidTypeArgumentInConstTypedLiteral(arguments, CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_LIST);
         }
       }
     }
     return super.visitListLiteral(node);
   }
   Object visitMapLiteral(MapLiteral node) {
-    TypeArgumentList typeArguments2 = node.typeArguments;
-    if (typeArguments2 != null) {
-      NodeList<TypeName> arguments2 = typeArguments2.arguments;
-      if (arguments2.length != 0) {
-        checkForInvalidTypeArgumentForKey(arguments2);
+    TypeArgumentList typeArguments = node.typeArguments;
+    if (typeArguments != null) {
+      NodeList<TypeName> arguments = typeArguments.arguments;
+      if (arguments.length != 0) {
+        checkForInvalidTypeArgumentForKey(arguments);
         if (node.modifier != null) {
-          checkForInvalidTypeArgumentInConstTypedLiteral(arguments2, CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_MAP);
+          checkForInvalidTypeArgumentInConstTypedLiteral(arguments, CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_MAP);
         }
       }
     }
     checkForNonConstMapAsExpressionStatement(node);
     return super.visitMapLiteral(node);
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement previousFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
@@ skipping 104 matching lines @@
   }
   Object visitTypeParameter(TypeParameter node) {
     checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME);
     return super.visitTypeParameter(node);
   }
   Object visitVariableDeclaration(VariableDeclaration node) {
     SimpleIdentifier nameNode = node.name;
     Expression initializerNode = node.initializer;
     checkForInvalidAssignment2(nameNode, initializerNode);
     nameNode.accept(this);
-    String name2 = nameNode.name;
-    javaSetAdd(_namesForReferenceToDeclaredVariableInInitializer, name2);
+    String name = nameNode.name;
+    javaSetAdd(_namesForReferenceToDeclaredVariableInInitializer, name);
     try {
       if (initializerNode != null) {
         initializerNode.accept(this);
       }
     } finally {
-      _namesForReferenceToDeclaredVariableInInitializer.remove(name2);
+      _namesForReferenceToDeclaredVariableInInitializer.remove(name);
     }
     return null;
   }
   Object visitVariableDeclarationList(VariableDeclarationList node) {
     checkForBuiltInIdentifierAsName2(node);
     return super.visitVariableDeclarationList(node);
   }
   Object visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     checkForFinalNotInitialized2(node.variables);
     return super.visitVariableDeclarationStatement(node);
@@ skipping 35 matching lines @@
             foundError = true;
           }
         } else if (identical(state, INIT_STATE.INIT_IN_FIELD_FORMAL)) {
           if (fieldElement.isFinal() || fieldElement.isConst()) {
             _errorReporter.reportError2(CompileTimeErrorCode.FINAL_INITIALIZED_MULTIPLE_TIMES, formalParameter.identifier, [fieldElement.displayName]);
             foundError = true;
           }
         }
       }
     }
-    NodeList<ConstructorInitializer> initializers2 = node.initializers;
-    for (ConstructorInitializer constructorInitializer in initializers2) {
+    NodeList<ConstructorInitializer> initializers = node.initializers;
+    for (ConstructorInitializer constructorInitializer in initializers) {
       if (constructorInitializer is ConstructorFieldInitializer) {
         ConstructorFieldInitializer constructorFieldInitializer = constructorInitializer as ConstructorFieldInitializer;
-        SimpleIdentifier fieldName2 = constructorFieldInitializer.fieldName;
-        Element element2 = fieldName2.element;
-        if (element2 is FieldElement) {
-          FieldElement fieldElement = element2 as FieldElement;
+        SimpleIdentifier fieldName = constructorFieldInitializer.fieldName;
+        Element element = fieldName.element;
+        if (element is FieldElement) {
+          FieldElement fieldElement = element as FieldElement;
           INIT_STATE state = fieldElementsMap[fieldElement];
           if (identical(state, INIT_STATE.NOT_INIT)) {
             fieldElementsMap[fieldElement] = INIT_STATE.INIT_IN_INITIALIZERS;
           } else if (identical(state, INIT_STATE.INIT_IN_DECLARATION)) {
             if (fieldElement.isFinal() || fieldElement.isConst()) {
-              _errorReporter.reportError2(CompileTimeErrorCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION, fieldName2, []);
+              _errorReporter.reportError2(CompileTimeErrorCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION, fieldName, []);
               foundError = true;
             }
           } else if (identical(state, INIT_STATE.INIT_IN_FIELD_FORMAL)) {
-            _errorReporter.reportError2(CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER, fieldName2, []);
+            _errorReporter.reportError2(CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER, fieldName, []);
             foundError = true;
           } else if (identical(state, INIT_STATE.INIT_IN_INITIALIZERS)) {
-            _errorReporter.reportError2(CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS, fieldName2, [fieldElement.displayName]);
+            _errorReporter.reportError2(CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS, fieldName, [fieldElement.displayName]);
             foundError = true;
           }
         }
       }
     }
     return foundError;
   }
 
   /**
    * This checks the passed method declaration against override-error codes.
@@ skipping 276 matching lines @@
    * already exported by other export directive.
    * @param node the export directive node to report problem on
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#AMBIGUOUS_EXPORT
    */
   bool checkForAmbiguousExport(ExportDirective node) {
     if (node.element is! ExportElement) {
       return false;
     }
     ExportElement exportElement = node.element as ExportElement;
-    LibraryElement exportedLibrary2 = exportElement.exportedLibrary;
-    if (exportedLibrary2 == null) {
+    LibraryElement exportedLibrary = exportElement.exportedLibrary;
+    if (exportedLibrary == null) {
       return false;
     }
     Namespace namespace = new NamespaceBuilder().createExportNamespace(exportElement);
     Set<String> newNames = namespace.definedNames.keys.toSet();
     for (String name in newNames) {
       ExportElement prevElement = _exportedNames[name];
       if (prevElement != null && prevElement != exportElement) {
-        _errorReporter.reportError2(CompileTimeErrorCode.AMBIGUOUS_EXPORT, node, [name, prevElement.exportedLibrary.definingCompilationUnit.displayName, exportedLibrary2.definingCompilationUnit.displayName]);
+        _errorReporter.reportError2(CompileTimeErrorCode.AMBIGUOUS_EXPORT, node, [name, prevElement.exportedLibrary.definingCompilationUnit.displayName, exportedLibrary.definingCompilationUnit.displayName]);
         return true;
       } else {
         _exportedNames[name] = exportElement;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed argument definition test identifier is a parameter.
    * @param node the {@link ArgumentDefinitionTest} to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#ARGUMENT_DEFINITION_TEST_NON_PARAMETER
    */
   bool checkForArgumentDefinitionTestNonParameter(ArgumentDefinitionTest node) {
-    SimpleIdentifier identifier2 = node.identifier;
-    Element element2 = identifier2.element;
-    if (element2 != null && element2 is! ParameterElement) {
-      _errorReporter.reportError2(CompileTimeErrorCode.ARGUMENT_DEFINITION_TEST_NON_PARAMETER, identifier2, [identifier2.name]);
+    SimpleIdentifier identifier = node.identifier;
+    Element element = identifier.element;
+    if (element != null && element is! ParameterElement) {
+      _errorReporter.reportError2(CompileTimeErrorCode.ARGUMENT_DEFINITION_TEST_NON_PARAMETER, identifier, [identifier.name]);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed arguments can be assigned to their corresponding parameters.
    * @param node the arguments to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
@@ skipping 12 matching lines @@
   /**
    * This verifies that the passed argument can be assigned to their corresponding parameters.
    * @param node the argument to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
    */
   bool checkForArgumentTypeNotAssignable2(Expression argument) {
     if (argument == null) {
       return false;
     }
-    ParameterElement staticParameterElement2 = argument.staticParameterElement;
-    Type2 staticParameterType = staticParameterElement2 == null ? null : staticParameterElement2.type;
+    ParameterElement staticParameterElement = argument.staticParameterElement;
+    Type2 staticParameterType = staticParameterElement == null ? null : staticParameterElement.type;
     Type2 staticArgumentType = getStaticType(argument);
     if (staticArgumentType == null || staticParameterType == null) {
       return false;
     }
     if (_strictMode) {
       if (staticArgumentType.isAssignableTo(staticParameterType)) {
         return false;
       }
       _errorReporter.reportError2(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, argument, [staticArgumentType.displayName, staticParameterType.displayName]);
       return true;
@@ skipping 64 matching lines @@
    * on the identifier if it is a keyword.
    * @param identifier the identifier to check to ensure that it is not a keyword
    * @param errorCode if the passed identifier is a keyword then this error code is created on the
    * identifier, the error code will be one of{@link CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE_NAME},{@link CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME} or{@link CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME}
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE_NAME
    * @see CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME
    * @see CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME
    */
   bool checkForBuiltInIdentifierAsName(SimpleIdentifier identifier, ErrorCode errorCode) {
-    sc.Token token2 = identifier.token;
-    if (identical(token2.type, sc.TokenType.KEYWORD)) {
+    sc.Token token = identifier.token;
+    if (identical(token.type, sc.TokenType.KEYWORD)) {
       _errorReporter.reportError2(errorCode, identifier, [identifier.name]);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed variable declaration list does not have a built-in identifier.
    * @param node the variable declaration list to check
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE
    */
   bool checkForBuiltInIdentifierAsName2(VariableDeclarationList node) {
     TypeName typeName = node.type;
     if (typeName != null) {
       Identifier identifier = typeName.name;
       if (identifier is SimpleIdentifier) {
         SimpleIdentifier simpleIdentifier = identifier as SimpleIdentifier;
-        sc.Token token2 = simpleIdentifier.token;
-        if (identical(token2.type, sc.TokenType.KEYWORD)) {
-          if (((token2 as sc.KeywordToken)).keyword != sc.Keyword.DYNAMIC) {
+        sc.Token token = simpleIdentifier.token;
+        if (identical(token.type, sc.TokenType.KEYWORD)) {
+          if (((token as sc.KeywordToken)).keyword != sc.Keyword.DYNAMIC) {
             _errorReporter.reportError2(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE, identifier, [identifier.name]);
             return true;
           }
         }
       }
     }
     return false;
   }
 
   /**
    * This verifies that the given switch case is terminated with 'break', 'continue', 'return' or
    * 'throw'.
    * @param node the switch case to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CASE_BLOCK_NOT_TERMINATED
    */
   bool checkForCaseBlockNotTerminated(SwitchCase node) {
-    NodeList<Statement> statements2 = node.statements;
-    if (statements2.isEmpty) {
-      ASTNode parent2 = node.parent;
-      if (parent2 is SwitchStatement) {
-        SwitchStatement switchStatement = parent2 as SwitchStatement;
-        NodeList<SwitchMember> members2 = switchStatement.members;
-        int index = members2.indexOf(node);
-        if (index != -1 && index < members2.length - 1) {
+    NodeList<Statement> statements = node.statements;
+    if (statements.isEmpty) {
+      ASTNode parent = node.parent;
+      if (parent is SwitchStatement) {
+        SwitchStatement switchStatement = parent as SwitchStatement;
+        NodeList<SwitchMember> members = switchStatement.members;
+        int index = members.indexOf(node);
+        if (index != -1 && index < members.length - 1) {
           return false;
         }
       }
     } else {
-      Statement statement = statements2[statements2.length - 1];
+      Statement statement = statements[statements.length - 1];
       if (statement is BreakStatement || statement is ContinueStatement || statement is ReturnStatement) {
         return false;
       }
       if (statement is ExpressionStatement) {
-        Expression expression2 = ((statement as ExpressionStatement)).expression;
-        if (expression2 is ThrowExpression) {
+        Expression expression = ((statement as ExpressionStatement)).expression;
+        if (expression is ThrowExpression) {
           return false;
         }
       }
     }
     _errorReporter.reportError4(StaticWarningCode.CASE_BLOCK_NOT_TERMINATED, node.keyword, []);
     return true;
   }
 
   /**
    * This verifies that the switch cases in the given switch statement is terminated with 'break',
    * 'continue', 'return' or 'throw'.
    * @param node the switch statement containing the cases to be checked
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CASE_BLOCK_NOT_TERMINATED
    */
   bool checkForCaseBlocksNotTerminated(SwitchStatement node) {
     bool foundError = false;
-    NodeList<SwitchMember> members2 = node.members;
-    int lastMember = members2.length - 1;
+    NodeList<SwitchMember> members = node.members;
+    int lastMember = members.length - 1;
     for (int i = 0; i < lastMember; i++) {
-      SwitchMember member = members2[i];
+      SwitchMember member = members[i];
       if (member is SwitchCase) {
         foundError = javaBooleanOr(foundError, checkForCaseBlockNotTerminated((member as SwitchCase)));
       }
     }
     return foundError;
   }
 
   /**
    * This verifies that the passed switch statement does not have a case expression with the
    * operator '==' overridden.
    * @param node the switch statement to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS
    */
   bool checkForCaseExpressionTypeImplementsEquals(SwitchStatement node) {
-    Expression expression2 = node.expression;
-    Type2 type = getStaticType(expression2);
+    Expression expression = node.expression;
+    Type2 type = getStaticType(expression);
     if (type != null && type != _typeProvider.intType && type != _typeProvider.stringType) {
-      Element element2 = type.element;
-      if (element2 is ClassElement) {
-        ClassElement classElement = element2 as ClassElement;
+      Element element = type.element;
+      if (element is ClassElement) {
+        ClassElement classElement = element as ClassElement;
         MethodElement method = classElement.lookUpMethod("==", _currentLibrary);
         if (method != null && method.enclosingElement.type != _typeProvider.objectType) {
-          _errorReporter.reportError2(CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS, expression2, [element2.displayName]);
+          _errorReporter.reportError2(CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS, expression, [element.displayName]);
           return true;
         }
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed method declaration is abstract only if the enclosing class is
    * also abstract.
@@ skipping 16 matching lines @@
    * @param node the constructor declaration to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#DUPLICATE_CONSTRUCTOR_DEFAULT
    * @see CompileTimeErrorCode#DUPLICATE_CONSTRUCTOR_NAME
    * @see CompileTimeErrorCode#CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD
    * @see CompileTimeErrorCode#CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD
    */
   bool checkForConflictingConstructorNameAndMember(ConstructorDeclaration node) {
     ConstructorElement constructorElement = node.element;
     SimpleIdentifier constructorName = node.name;
-    String name2 = constructorElement.name;
+    String name = constructorElement.name;
     ClassElement classElement = constructorElement.enclosingElement;
-    List<ConstructorElement> constructors2 = classElement.constructors;
-    for (ConstructorElement otherConstructor in constructors2) {
+    List<ConstructorElement> constructors = classElement.constructors;
+    for (ConstructorElement otherConstructor in constructors) {
       if (identical(otherConstructor, constructorElement)) {
         continue;
       }
-      if (name2 == otherConstructor.name) {
-        if (name2 == null || name2.length == 0) {
+      if (name == otherConstructor.name) {
+        if (name == null || name.length == 0) {
           _errorReporter.reportError2(CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT, node, []);
         } else {
-          _errorReporter.reportError2(CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME, node, [name2]);
+          _errorReporter.reportError2(CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME, node, [name]);
         }
         return true;
       }
     }
     if (constructorName != null && constructorElement != null && !constructorName.isSynthetic()) {
-      List<FieldElement> fields2 = classElement.fields;
-      for (FieldElement field in fields2) {
-        if (field.name == name2) {
-          _errorReporter.reportError2(CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD, node, [name2]);
+      List<FieldElement> fields = classElement.fields;
+      for (FieldElement field in fields) {
+        if (field.name == name) {
+          _errorReporter.reportError2(CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD, node, [name]);
           return true;
         }
       }
-      List<MethodElement> methods2 = classElement.methods;
-      for (MethodElement method in methods2) {
-        if (method.name == name2) {
-          _errorReporter.reportError2(CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD, node, [name2]);
+      List<MethodElement> methods = classElement.methods;
+      for (MethodElement method in methods) {
+        if (method.name == name) {
+          _errorReporter.reportError2(CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD, node, [name]);
           return true;
         }
       }
     }
     return false;
   }
 
   /**
    * This verifies that the superclass of the enclosing class does not declare accessible static
    * member with the same name as the passed instance getter/setter method declaration.
    * @param node the method declaration to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER
    * @see StaticWarningCode#CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER
    */
   bool checkForConflictingInstanceGetterAndSuperclassMember(MethodDeclaration node) {
     if (node.isStatic()) {
       return false;
     }
     SimpleIdentifier nameNode = node.name;
     if (nameNode == null) {
       return false;
     }
-    String name2 = nameNode.name;
+    String name = nameNode.name;
     if (_enclosingClass == null) {
       return false;
     }
     InterfaceType enclosingType = _enclosingClass.type;
     ExecutableElement superElement;
-    superElement = enclosingType.lookUpGetterInSuperclass(name2, _currentLibrary);
+    superElement = enclosingType.lookUpGetterInSuperclass(name, _currentLibrary);
     if (superElement == null) {
-      superElement = enclosingType.lookUpSetterInSuperclass(name2, _currentLibrary);
+      superElement = enclosingType.lookUpSetterInSuperclass(name, _currentLibrary);
     }
     if (superElement == null) {
-      superElement = enclosingType.lookUpMethodInSuperclass(name2, _currentLibrary);
+      superElement = enclosingType.lookUpMethodInSuperclass(name, _currentLibrary);
     }
     if (superElement == null) {
       return false;
     }
     if (!superElement.isStatic()) {
       return false;
     }
     ClassElement superElementClass = superElement.enclosingElement as ClassElement;
     InterfaceType superElementType = superElementClass.type;
     if (node.isGetter()) {
@@ skipping 12 matching lines @@
    * @see StaticWarningCode#CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER
    */
   bool checkForConflictingStaticGetterAndInstanceSetter(MethodDeclaration node) {
     if (!node.isStatic()) {
       return false;
     }
     SimpleIdentifier nameNode = node.name;
     if (nameNode == null) {
       return false;
     }
-    String name2 = nameNode.name;
+    String name = nameNode.name;
     if (_enclosingClass == null) {
       return false;
     }
     InterfaceType enclosingType = _enclosingClass.type;
-    ExecutableElement setter = enclosingType.lookUpSetter(name2, _currentLibrary);
+    ExecutableElement setter = enclosingType.lookUpSetter(name, _currentLibrary);
     if (setter == null) {
       return false;
     }
     if (setter.isStatic()) {
       return false;
     }
     ClassElement setterClass = setter.enclosingElement as ClassElement;
     InterfaceType setterType = setterClass.type;
     _errorReporter.reportError2(StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER, nameNode, [setterType.displayName]);
     return true;
   }
 
   /**
    * This verifies that the enclosing class does not have an instance member with the same name as
    * the passed static getter method declaration.
    * @param node the method declaration to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER
    */
   bool checkForConflictingStaticSetterAndInstanceMember(MethodDeclaration node) {
     if (!node.isStatic()) {
       return false;
     }
     SimpleIdentifier nameNode = node.name;
     if (nameNode == null) {
       return false;
     }
-    String name2 = nameNode.name;
+    String name = nameNode.name;
     if (_enclosingClass == null) {
       return false;
     }
     InterfaceType enclosingType = _enclosingClass.type;
     ExecutableElement member;
-    member = enclosingType.lookUpMethod(name2, _currentLibrary);
+    member = enclosingType.lookUpMethod(name, _currentLibrary);
     if (member == null) {
-      member = enclosingType.lookUpGetter(name2, _currentLibrary);
+      member = enclosingType.lookUpGetter(name, _currentLibrary);
     }
     if (member == null) {
-      member = enclosingType.lookUpSetter(name2, _currentLibrary);
+      member = enclosingType.lookUpSetter(name, _currentLibrary);
     }
     if (member == null) {
       return false;
     }
     if (member.isStatic()) {
       return false;
     }
     ClassElement memberClass = member.enclosingElement as ClassElement;
     InterfaceType memberType = memberClass.type;
     _errorReporter.reportError2(StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER, nameNode, [memberType.displayName]);
@@ skipping 54 matching lines @@
    * class.
    * @param node the instance creation expression to evaluate
    * @param typeName the {@link TypeName} of the {@link ConstructorName} from the{@link InstanceCreationExpression}, this is the AST node that the error is attached to
    * @param type the type being constructed with this {@link InstanceCreationExpression}
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONST_WITH_ABSTRACT_CLASS
    * @see StaticWarningCode#NEW_WITH_ABSTRACT_CLASS
    */
   bool checkForConstOrNewWithAbstractClass(InstanceCreationExpression node, TypeName typeName, InterfaceType type) {
     if (type.element.isAbstract()) {
-      ConstructorElement element2 = node.element;
-      if (element2 != null && !element2.isFactory()) {
+      ConstructorElement element = node.element;
+      if (element != null && !element.isFactory()) {
         if (identical(((node.keyword as sc.KeywordToken)).keyword, sc.Keyword.CONST)) {
           _errorReporter.reportError2(StaticWarningCode.CONST_WITH_ABSTRACT_CLASS, typeName, []);
         } else {
           _errorReporter.reportError2(StaticWarningCode.NEW_WITH_ABSTRACT_CLASS, typeName, []);
         }
         return true;
       }
     }
     return false;
   }
@@ skipping 19 matching lines @@
   /**
    * This verifies that the passed 'const' instance creation expression does not reference any type
    * parameters.
    * <p>
    * This method assumes that the instance creation was tested to be 'const' before being called.
    * @param node the instance creation expression to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_WITH_TYPE_PARAMETERS
    */
   bool checkForConstWithTypeParameters(InstanceCreationExpression node) {
-    ConstructorName constructorName2 = node.constructorName;
-    if (constructorName2 == null) {
+    ConstructorName constructorName = node.constructorName;
+    if (constructorName == null) {
       return false;
     }
-    TypeName typeName = constructorName2.type;
+    TypeName typeName = constructorName.type;
     return checkForConstWithTypeParameters2(typeName);
   }
 
   /**
    * This verifies that the passed type name does not reference any type parameters.
    * @param typeName the type name to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_WITH_TYPE_PARAMETERS
    */
   bool checkForConstWithTypeParameters2(TypeName typeName) {
     if (typeName == null) {
       return false;
     }
-    Identifier name2 = typeName.name;
-    if (name2 == null) {
+    Identifier name = typeName.name;
+    if (name == null) {
       return false;
     }
-    if (name2.element is TypeVariableElement) {
-      _errorReporter.reportError2(CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS, name2, []);
+    if (name.element is TypeVariableElement) {
+      _errorReporter.reportError2(CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS, name, []);
     }
-    TypeArgumentList typeArguments2 = typeName.typeArguments;
-    if (typeArguments2 != null) {
+    TypeArgumentList typeArguments = typeName.typeArguments;
+    if (typeArguments != null) {
       bool hasError = false;
-      for (TypeName argument in typeArguments2.arguments) {
+      for (TypeName argument in typeArguments.arguments) {
         hasError = javaBooleanOr(hasError, checkForConstWithTypeParameters2(argument));
       }
       return hasError;
     }
     return false;
   }
 
   /**
    * This verifies that if the passed 'const' instance creation expression is being invoked on the
    * resolved constructor.
    * <p>
    * This method assumes that the instance creation was tested to be 'const' before being called.
    * @param node the instance creation expression to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_WITH_UNDEFINED_CONSTRUCTOR
    * @see CompileTimeErrorCode#CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT
    */
   bool checkForConstWithUndefinedConstructor(InstanceCreationExpression node) {
     if (node.element != null) {
       return false;
     }
-    ConstructorName constructorName2 = node.constructorName;
-    if (constructorName2 == null) {
+    ConstructorName constructorName = node.constructorName;
+    if (constructorName == null) {
       return false;
     }
-    TypeName type2 = constructorName2.type;
-    if (type2 == null) {
+    TypeName type = constructorName.type;
+    if (type == null) {
       return false;
     }
-    Identifier className = type2.name;
-    SimpleIdentifier name2 = constructorName2.name;
-    if (name2 != null) {
-      _errorReporter.reportError2(CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR, name2, [className, name2]);
+    Identifier className = type.name;
+    SimpleIdentifier name = constructorName.name;
+    if (name != null) {
+      _errorReporter.reportError2(CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR, name, [className, name]);
     } else {
-      _errorReporter.reportError2(CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT, constructorName2, [className]);
+      _errorReporter.reportError2(CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT, constructorName, [className]);
     }
     return true;
   }
 
   /**
    * This verifies that there are no default parameters in the passed function type alias.
    * @param node the function type alias to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS
    */
   bool checkForDefaultValueInFunctionTypeAlias(FunctionTypeAlias node) {
     bool result = false;
     FormalParameterList formalParameterList = node.parameters;
-    NodeList<FormalParameter> parameters2 = formalParameterList.parameters;
-    for (FormalParameter formalParameter in parameters2) {
+    NodeList<FormalParameter> parameters = formalParameterList.parameters;
+    for (FormalParameter formalParameter in parameters) {
       if (formalParameter is DefaultFormalParameter) {
         DefaultFormalParameter defaultFormalParameter = formalParameter as DefaultFormalParameter;
         if (defaultFormalParameter.defaultValue != null) {
           _errorReporter.reportError2(CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS, node, []);
           result = true;
         }
       }
     }
     return result;
   }
 
   /**
    * This verifies the passed import has unique name among other exported libraries.
    * @param node the export directive to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#EXPORT_DUPLICATED_LIBRARY_NAME
    */
   bool checkForExportDuplicateLibraryName(ExportDirective node) {
     Element nodeElement = node.element;
     if (nodeElement is! ExportElement) {
       return false;
     }
     ExportElement nodeExportElement = nodeElement as ExportElement;
     LibraryElement nodeLibrary = nodeExportElement.exportedLibrary;
     if (nodeLibrary == null) {
       return false;
     }
-    String name2 = nodeLibrary.name;
-    LibraryElement prevLibrary = _nameToExportElement[name2];
+    String name = nodeLibrary.name;
+    LibraryElement prevLibrary = _nameToExportElement[name];
     if (prevLibrary != null) {
       if (prevLibrary != nodeLibrary) {
-        _errorReporter.reportError2(StaticWarningCode.EXPORT_DUPLICATED_LIBRARY_NAME, node, [prevLibrary.definingCompilationUnit.displayName, nodeLibrary.definingCompilationUnit.displayName, name2]);
+        _errorReporter.reportError2(StaticWarningCode.EXPORT_DUPLICATED_LIBRARY_NAME, node, [prevLibrary.definingCompilationUnit.displayName, nodeLibrary.definingCompilationUnit.displayName, name]);
         return true;
       }
     } else {
-      _nameToExportElement[name2] = nodeLibrary;
+      _nameToExportElement[name] = nodeLibrary;
     }
     return false;
   }
 
   /**
    * Check that if the visiting library is not system, then any passed library should not be SDK
    * internal library.
    * @param node the export directive to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#EXPORT_INTERNAL_LIBRARY
    */
   bool checkForExportInternalLibrary(ExportDirective node) {
     if (_isInSystemLibrary) {
       return false;
     }
-    Element element2 = node.element;
-    if (element2 is! ExportElement) {
+    Element element = node.element;
+    if (element is! ExportElement) {
       return false;
     }
-    ExportElement exportElement = element2 as ExportElement;
+    ExportElement exportElement = element as ExportElement;
     DartSdk sdk = _currentLibrary.context.sourceFactory.dartSdk;
-    String uri2 = exportElement.uri;
-    SdkLibrary sdkLibrary = sdk.getSdkLibrary(uri2);
+    String uri = exportElement.uri;
+    SdkLibrary sdkLibrary = sdk.getSdkLibrary(uri);
     if (sdkLibrary == null) {
       return false;
     }
     if (!sdkLibrary.isInternal()) {
       return false;
     }
     _errorReporter.reportError2(CompileTimeErrorCode.EXPORT_INTERNAL_LIBRARY, node, [node.uri]);
     return true;
   }
 
@@ skipping 52 matching lines @@
    * @see CompileTimeErrorCode#CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE
    * @see StaticWarningCode#FIELD_INITIALIZER_NOT_ASSIGNABLE
    */
   bool checkForFieldInitializerNotAssignable(ConstructorFieldInitializer node) {
     Element fieldNameElement = node.fieldName.element;
     if (fieldNameElement is! FieldElement) {
       return false;
     }
     FieldElement fieldElement = fieldNameElement as FieldElement;
     Type2 fieldType = fieldElement.type;
-    Expression expression2 = node.expression;
-    if (expression2 == null) {
+    Expression expression = node.expression;
+    if (expression == null) {
       return false;
     }
-    Type2 staticType = getStaticType(expression2);
+    Type2 staticType = getStaticType(expression);
     if (staticType == null) {
       return false;
     }
     if (staticType.isAssignableTo(fieldType)) {
       return false;
     } else if (_strictMode) {
       if (_isEnclosingConstructorConst) {
-        _errorReporter.reportError2(CompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE, expression2, [staticType.displayName, fieldType.displayName]);
+        _errorReporter.reportError2(CompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE, expression, [staticType.displayName, fieldType.displayName]);
       } else {
-        _errorReporter.reportError2(StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE, expression2, [staticType.displayName, fieldType.displayName]);
+        _errorReporter.reportError2(StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE, expression, [staticType.displayName, fieldType.displayName]);
       }
       return true;
     }
-    Type2 propagatedType = getPropagatedType(expression2);
+    Type2 propagatedType = getPropagatedType(expression);
     if (propagatedType != null && propagatedType.isAssignableTo(fieldType)) {
       return false;
     }
     if (_isEnclosingConstructorConst) {
-      _errorReporter.reportError2(CompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE, expression2, [(propagatedType == null ? staticType : propagatedType).displayName, fieldType.displayName]);
+      _errorReporter.reportError2(CompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE, expression, [(propagatedType == null ? staticType : propagatedType).displayName, fieldType.displayName]);
     } else {
-      _errorReporter.reportError2(StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE, expression2, [(propagatedType == null ? staticType : propagatedType).displayName, fieldType.displayName]);
+      _errorReporter.reportError2(StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE, expression, [(propagatedType == null ? staticType : propagatedType).displayName, fieldType.displayName]);
     }
     return true;
   }
 
   /**
    * This verifies that the passed field formal parameter is in a constructor declaration.
    * @param node the field formal parameter to test
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR
    */
@@ skipping 44 matching lines @@
   /**
    * This verifies that the passed variable declaration list has only initialized variables if the
    * list is final or const. This method is called by{@link #checkForFinalNotInitialized(ClassDeclaration)},{@link #visitTopLevelVariableDeclaration(TopLevelVariableDeclaration)} and{@link #visitVariableDeclarationStatement(VariableDeclarationStatement)}.
    * @param node the class declaration to test
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#FINAL_NOT_INITIALIZED
    */
   bool checkForFinalNotInitialized2(VariableDeclarationList node) {
     bool foundError = false;
     if (!node.isSynthetic() && (node.isConst() || node.isFinal())) {
-      NodeList<VariableDeclaration> variables2 = node.variables;
-      for (VariableDeclaration variable in variables2) {
+      NodeList<VariableDeclaration> variables = node.variables;
+      for (VariableDeclaration variable in variables) {
         if (variable.initializer == null) {
           _errorReporter.reportError2(StaticWarningCode.FINAL_NOT_INITIALIZED, variable, [variable.name.name]);
           foundError = true;
         }
       }
     }
     return foundError;
   }
 
   /**
@@ skipping 18 matching lines @@
    * This verifies that if the passed identifier is part of constructor initializer, then it does
    * not reference implicitly 'this' expression.
    * @param node the simple identifier to test
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#IMPLICIT_THIS_REFERENCE_IN_INITIALIZER
    */
   bool checkForImplicitThisReferenceInInitializer(SimpleIdentifier node) {
     if (!_isInConstructorInitializer) {
       return false;
     }
-    Element element2 = node.element;
-    if (!(element2 is MethodElement || element2 is PropertyAccessorElement)) {
+    Element element = node.element;
+    if (!(element is MethodElement || element is PropertyAccessorElement)) {
       return false;
     }
-    ExecutableElement executableElement = element2 as ExecutableElement;
+    ExecutableElement executableElement = element as ExecutableElement;
     if (executableElement.isStatic()) {
       return false;
     }
-    Element enclosingElement2 = element2.enclosingElement;
-    if (enclosingElement2 is! ClassElement) {
+    Element enclosingElement = element.enclosingElement;
+    if (enclosingElement is! ClassElement) {
       return false;
     }
-    ASTNode parent2 = node.parent;
-    if (parent2 is MethodInvocation) {
-      MethodInvocation invocation = parent2 as MethodInvocation;
+    ASTNode parent = node.parent;
+    if (parent is MethodInvocation) {
+      MethodInvocation invocation = parent as MethodInvocation;
       if (identical(invocation.methodName, node) && invocation.realTarget != null) {
         return false;
       }
     }
     {
-      if (parent2 is PropertyAccess) {
-        PropertyAccess access = parent2 as PropertyAccess;
+      if (parent is PropertyAccess) {
+        PropertyAccess access = parent as PropertyAccess;
         if (identical(access.propertyName, node) && access.realTarget != null) {
           return false;
         }
       }
-      if (parent2 is PrefixedIdentifier) {
-        PrefixedIdentifier prefixed = parent2 as PrefixedIdentifier;
+      if (parent is PrefixedIdentifier) {
+        PrefixedIdentifier prefixed = parent as PrefixedIdentifier;
         if (identical(prefixed.identifier, node)) {
           return false;
         }
       }
     }
     _errorReporter.reportError2(CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER, node, []);
     return true;
   }
 
   /**
    * This verifies the passed import has unique name among other imported libraries.
    * @param node the import directive to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#IMPORT_DUPLICATED_LIBRARY_NAME
    */
   bool checkForImportDuplicateLibraryName(ImportDirective node) {
     Element nodeElement = node.element;
     if (nodeElement is! ImportElement) {
       return false;
     }
     ImportElement nodeImportElement = nodeElement as ImportElement;
     LibraryElement nodeLibrary = nodeImportElement.importedLibrary;
     if (nodeLibrary == null) {
       return false;
     }
-    String name2 = nodeLibrary.name;
-    LibraryElement prevLibrary = _nameToImportElement[name2];
+    String name = nodeLibrary.name;
+    LibraryElement prevLibrary = _nameToImportElement[name];
     if (prevLibrary != null) {
       if (prevLibrary != nodeLibrary) {
-        _errorReporter.reportError2(StaticWarningCode.IMPORT_DUPLICATED_LIBRARY_NAME, node, [prevLibrary.definingCompilationUnit.displayName, nodeLibrary.definingCompilationUnit.displayName, name2]);
+        _errorReporter.reportError2(StaticWarningCode.IMPORT_DUPLICATED_LIBRARY_NAME, node, [prevLibrary.definingCompilationUnit.displayName, nodeLibrary.definingCompilationUnit.displayName, name]);
         return true;
       }
     } else {
-      _nameToImportElement[name2] = nodeLibrary;
+      _nameToImportElement[name] = nodeLibrary;
     }
     return false;
   }
 
   /**
    * Check that if the visiting library is not system, then any passed library should not be SDK
    * internal library.
    * @param node the import directive to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#IMPORT_INTERNAL_LIBRARY
    */
   bool checkForImportInternalLibrary(ImportDirective node) {
     if (_isInSystemLibrary) {
       return false;
     }
-    Element element2 = node.element;
-    if (element2 is! ImportElement) {
+    Element element = node.element;
+    if (element is! ImportElement) {
       return false;
     }
-    ImportElement importElement = element2 as ImportElement;
+    ImportElement importElement = element as ImportElement;
     DartSdk sdk = _currentLibrary.context.sourceFactory.dartSdk;
-    String uri2 = importElement.uri;
-    SdkLibrary sdkLibrary = sdk.getSdkLibrary(uri2);
+    String uri = importElement.uri;
+    SdkLibrary sdkLibrary = sdk.getSdkLibrary(uri);
     if (sdkLibrary == null) {
       return false;
     }
     if (!sdkLibrary.isInternal()) {
       return false;
     }
     _errorReporter.reportError2(CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY, node, [node.uri]);
     return true;
   }
 
   /**
    * This verifies that the passed switch statement case expressions all have the same type.
    * @param node the switch statement to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#INCONSISTENT_CASE_EXPRESSION_TYPES
    */
   bool checkForInconsistentCaseExpressionTypes(SwitchStatement node) {
     NodeList<SwitchMember> switchMembers = node.members;
     bool foundError = false;
     Type2 firstType = null;
     for (SwitchMember switchMember in switchMembers) {
       if (switchMember is SwitchCase) {
         SwitchCase switchCase = switchMember as SwitchCase;
-        Expression expression2 = switchCase.expression;
+        Expression expression = switchCase.expression;
         if (firstType == null) {
-          firstType = getBestType(expression2);
+          firstType = getBestType(expression);
         } else {
-          Type2 nType = getBestType(expression2);
+          Type2 nType = getBestType(expression);
           if (firstType != nType) {
-            _errorReporter.reportError2(CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES, expression2, [expression2.toSource(), firstType.displayName]);
+            _errorReporter.reportError2(CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES, expression, [expression.toSource(), firstType.displayName]);
             foundError = true;
           }
         }
       }
     }
     return foundError;
   }
 
   /**
    * For each class declaration, this method is called which verifies that all inherited members are
@@ skipping 263 matching lines @@
    * <p>
    * This method assumes that the instance creation was tested to be 'new' before being called.
    * @param node the instance creation expression to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticWarningCode#NEW_WITH_UNDEFINED_CONSTRUCTOR
    */
   bool checkForNewWithUndefinedConstructor(InstanceCreationExpression node) {
     if (node.element != null) {
       return false;
     }
-    ConstructorName constructorName2 = node.constructorName;
-    if (constructorName2 == null) {
+    ConstructorName constructorName = node.constructorName;
+    if (constructorName == null) {
       return false;
     }
-    TypeName type2 = constructorName2.type;
-    if (type2 == null) {
+    TypeName type = constructorName.type;
+    if (type == null) {
       return false;
     }
-    Identifier className = type2.name;
-    SimpleIdentifier name2 = constructorName2.name;
-    if (name2 != null) {
-      _errorReporter.reportError2(StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR, name2, [className, name2]);
+    Identifier className = type.name;
+    SimpleIdentifier name = constructorName.name;
+    if (name != null) {
+      _errorReporter.reportError2(StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR, name, [className, name]);
     } else {
-      _errorReporter.reportError2(StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT, constructorName2, [className]);
+      _errorReporter.reportError2(StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT, constructorName, [className]);
     }
     return true;
   }
 
   /**
    * This checks that passed class declaration overrides all members required by its superclasses
    * and interfaces.
    * @param node the {@link ClassDeclaration} to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS
    */
   bool checkForNonAbstractClassInheritsAbstractMember(ClassDeclaration node) {
     if (_enclosingClass.isAbstract()) {
       return false;
     }
     Set<ExecutableElement> missingOverrides = new Set<ExecutableElement>();
     Set<String> methodsInEnclosingClass = new Set<String>();
     Set<String> accessorsInEnclosingClass = new Set<String>();
-    List<MethodElement> methods2 = _enclosingClass.methods;
-    for (MethodElement method in methods2) {
+    List<MethodElement> methods = _enclosingClass.methods;
+    for (MethodElement method in methods) {
       javaSetAdd(methodsInEnclosingClass, method.name);
     }
-    List<PropertyAccessorElement> accessors2 = _enclosingClass.accessors;
-    for (PropertyAccessorElement accessor in accessors2) {
+    List<PropertyAccessorElement> accessors = _enclosingClass.accessors;
+    for (PropertyAccessorElement accessor in accessors) {
       javaSetAdd(accessorsInEnclosingClass, accessor.name);
     }
     Map<String, ExecutableElement> membersInheritedFromSuperclasses = _inheritanceManager.getMapOfMembersInheritedFromClasses(_enclosingClass);
     for (MapEntry<String, ExecutableElement> entry in getMapEntrySet(membersInheritedFromSuperclasses)) {
       ExecutableElement executableElt = entry.getValue();
       if (executableElt is MethodElement) {
         MethodElement methodElt = executableElt as MethodElement;
         if (methodElt.isAbstract()) {
           String methodName = entry.getKey();
           if (!methodsInEnclosingClass.contains(methodName)) {
@@ skipping 131 matching lines @@
   }
 
   /**
    * This verifies the passed method declaration of operator {@code \[\]=}, has {@code void} return
    * type.
    * @param node the method declaration to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticWarningCode#NON_VOID_RETURN_FOR_OPERATOR
    */
   bool checkForNonVoidReturnTypeForOperator(MethodDeclaration node) {
-    SimpleIdentifier name2 = node.name;
-    if (name2.name != "[]=") {
+    SimpleIdentifier name = node.name;
+    if (name.name != "[]=") {
       return false;
     }
     TypeName typeName = node.returnType;
     if (typeName != null) {
-      Type2 type2 = typeName.type;
-      if (type2 != null && !type2.isVoid()) {
+      Type2 type = typeName.type;
+      if (type != null && !type.isVoid()) {
         _errorReporter.reportError2(StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR, typeName, []);
       }
     }
     return false;
   }
 
   /**
    * This verifies the passed setter has no return type or the {@code void} return type.
    * @param typeName the type name to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticWarningCode#NON_VOID_RETURN_FOR_SETTER
    */
   bool checkForNonVoidReturnTypeForSetter(TypeName typeName) {
     if (typeName != null) {
-      Type2 type2 = typeName.type;
-      if (type2 != null && !type2.isVoid()) {
+      Type2 type = typeName.type;
+      if (type != null && !type.isVoid()) {
         _errorReporter.reportError2(StaticWarningCode.NON_VOID_RETURN_FOR_SETTER, typeName, []);
       }
     }
     return false;
   }
 
   /**
    * This verifies the passed operator-method declaration, does not have an optional parameter.
    * <p>
    * This method assumes that the method declaration was tested to be an operator declaration before
@@ skipping 18 matching lines @@
     return foundError;
   }
 
   /**
    * This checks for named optional parameters that begin with '_'.
    * @param node the default formal parameter to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#PRIVATE_OPTIONAL_PARAMETER
    */
   bool checkForPrivateOptionalParameter(DefaultFormalParameter node) {
-    sc.Token separator2 = node.separator;
-    if (separator2 != null && separator2.lexeme == ":") {
-      NormalFormalParameter parameter2 = node.parameter;
-      SimpleIdentifier name = parameter2.identifier;
+    sc.Token separator = node.separator;
+    if (separator != null && separator.lexeme == ":") {
+      NormalFormalParameter parameter = node.parameter;
+      SimpleIdentifier name = parameter.identifier;
       if (!name.isSynthetic() && name.name.startsWith("_")) {
         _errorReporter.reportError2(CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER, node, []);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This checks if the passed constructor declaration is the redirecting generative constructor and
    * references itself directly or indirectly.
    * @param node the constructor declaration to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#RECURSIVE_CONSTRUCTOR_REDIRECT
    */
   bool checkForRecursiveConstructorRedirect(ConstructorDeclaration node) {
     if (node.factoryKeyword != null) {
       return false;
     }
     for (ConstructorInitializer initializer in node.initializers) {
       if (initializer is RedirectingConstructorInvocation) {
-        ConstructorElement element2 = node.element;
-        if (!hasRedirectingFactoryConstructorCycle(element2)) {
+        ConstructorElement element = node.element;
+        if (!hasRedirectingFactoryConstructorCycle(element)) {
           return false;
         }
         _errorReporter.reportError2(CompileTimeErrorCode.RECURSIVE_CONSTRUCTOR_REDIRECT, initializer, []);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This checks if the passed constructor declaration has redirected constructor and references
    * itself directly or indirectly.
    * @param node the constructor declaration to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#RECURSIVE_FACTORY_REDIRECT
    */
   bool checkForRecursiveFactoryRedirect(ConstructorDeclaration node) {
     ConstructorName redirectedConstructorNode = node.redirectedConstructor;
     if (redirectedConstructorNode == null) {
       return false;
     }
-    ConstructorElement element2 = node.element;
-    if (!hasRedirectingFactoryConstructorCycle(element2)) {
+    ConstructorElement element = node.element;
+    if (!hasRedirectingFactoryConstructorCycle(element)) {
       return false;
     }
     _errorReporter.reportError2(CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT, redirectedConstructorNode, []);
     return true;
   }
 
   /**
    * This checks the class declaration is not a superinterface to itself.
    * @param classElt the class element to test
    * @param list a list containing the potentially cyclic implements path
    * @return {@code true} if and only if an error code is generated on the passed element
    * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE
    * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS
    * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS
    */
   bool checkForRecursiveInterfaceInheritance(ClassElement classElt, List<ClassElement> list) {
     if (classElt == null) {
       return false;
     }
-    InterfaceType supertype2 = classElt.supertype;
+    InterfaceType supertype = classElt.supertype;
     list.add(classElt);
     if (list.length != 1 && _enclosingClass == classElt) {
       String enclosingClassName = _enclosingClass.displayName;
       if (list.length > 2) {
         String separator = ", ";
         int listLength = list.length;
         JavaStringBuilder builder = new JavaStringBuilder();
         for (int i = 0; i < listLength; i++) {
           builder.append(list[i].displayName);
           if (i != listLength - 1) {
             builder.append(separator);
           }
         }
         _errorReporter.reportError3(CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE, _enclosingClass.nameOffset, enclosingClassName.length, [enclosingClassName, builder.toString()]);
         return true;
       } else if (list.length == 2) {
-        ErrorCode errorCode = supertype2 != null && _enclosingClass == supertype2.element ? CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS : CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS;
+        ErrorCode errorCode = supertype != null && _enclosingClass == supertype.element ? CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS : CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS;
         _errorReporter.reportError3(errorCode, _enclosingClass.nameOffset, enclosingClassName.length, [enclosingClassName]);
         return true;
       }
     }
     for (int i = 1; i < list.length - 1; i++) {
       if (classElt == list[i]) {
         list.removeAt(list.length - 1);
         return false;
       }
     }
     List<ClassElement> interfaceElements;
     List<InterfaceType> interfaceTypes = classElt.interfaces;
-    if (supertype2 != null && !supertype2.isObject()) {
+    if (supertype != null && !supertype.isObject()) {
       interfaceElements = new List<ClassElement>(interfaceTypes.length + 1);
-      interfaceElements[0] = supertype2.element;
+      interfaceElements[0] = supertype.element;
       for (int i = 0; i < interfaceTypes.length; i++) {
         interfaceElements[i + 1] = interfaceTypes[i].element;
       }
     } else {
       interfaceElements = new List<ClassElement>(interfaceTypes.length);
       for (int i = 0; i < interfaceTypes.length; i++) {
         interfaceElements[i] = interfaceTypes[i].element;
       }
     }
     for (ClassElement classElt2 in interfaceElements) {
@@ skipping 46 matching lines @@
    * itself directly or indirectly. TODO(scheglov)
    * @param node the constructor declaration to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#REDIRECT_TO_NON_CONST_CONSTRUCTOR
    */
   bool checkForRedirectToNonConstConstructor(ConstructorDeclaration node) {
     ConstructorName redirectedConstructorNode = node.redirectedConstructor;
     if (redirectedConstructorNode == null) {
       return false;
     }
-    ConstructorElement element2 = node.element;
-    if (element2 == null) {
+    ConstructorElement element = node.element;
+    if (element == null) {
       return false;
     }
-    if (!element2.isConst()) {
+    if (!element.isConst()) {
       return false;
     }
-    ConstructorElement redirectedConstructor2 = element2.redirectedConstructor;
-    if (redirectedConstructor2 == null) {
+    ConstructorElement redirectedConstructor = element.redirectedConstructor;
+    if (redirectedConstructor == null) {
       return false;
     }
-    if (redirectedConstructor2.isConst()) {
+    if (redirectedConstructor.isConst()) {
       return false;
     }
     _errorReporter.reportError2(CompileTimeErrorCode.REDIRECT_TO_NON_CONST_CONSTRUCTOR, redirectedConstructorNode, []);
     return true;
   }
 
   /**
    * This checks if the passed identifier is banned because it is part of the variable declaration
    * with the same name.
    * @param node the identifier to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER
    */
   bool checkForReferenceToDeclaredVariableInInitializer(SimpleIdentifier node) {
-    ASTNode parent2 = node.parent;
-    if (parent2 is PrefixedIdentifier) {
-      PrefixedIdentifier prefixedIdentifier = parent2 as PrefixedIdentifier;
+    ASTNode parent = node.parent;
+    if (parent is PrefixedIdentifier) {
+      PrefixedIdentifier prefixedIdentifier = parent as PrefixedIdentifier;
       if (identical(prefixedIdentifier.identifier, node)) {
         return false;
       }
     }
-    if (parent2 is PropertyAccess) {
-      PropertyAccess propertyAccess = parent2 as PropertyAccess;
+    if (parent is PropertyAccess) {
+      PropertyAccess propertyAccess = parent as PropertyAccess;
       if (identical(propertyAccess.propertyName, node)) {
         return false;
       }
     }
-    if (parent2 is MethodInvocation) {
-      MethodInvocation methodInvocation = parent2 as MethodInvocation;
+    if (parent is MethodInvocation) {
+      MethodInvocation methodInvocation = parent as MethodInvocation;
       if (methodInvocation.target != null && identical(methodInvocation.methodName, node)) {
         return false;
       }
     }
-    if (parent2 is ConstructorName) {
-      ConstructorName constructorName = parent2 as ConstructorName;
+    if (parent is ConstructorName) {
+      ConstructorName constructorName = parent as ConstructorName;
       if (identical(constructorName.name, node)) {
         return false;
       }
     }
-    if (parent2 is Label) {
-      Label label = parent2 as Label;
+    if (parent is Label) {
+      Label label = parent as Label;
       if (identical(label.label, node)) {
         return false;
       }
     }
-    String name2 = node.name;
-    if (!_namesForReferenceToDeclaredVariableInInitializer.contains(name2)) {
+    String name = node.name;
+    if (!_namesForReferenceToDeclaredVariableInInitializer.contains(name)) {
       return false;
     }
-    _errorReporter.reportError2(CompileTimeErrorCode.REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER, node, [name2]);
+    _errorReporter.reportError2(CompileTimeErrorCode.REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER, node, [name]);
     return true;
   }
 
   /**
    * This checks that the rethrow is inside of a catch clause.
    * @param node the rethrow expression to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#RETHROW_OUTSIDE_CATCH
    */
   bool checkForRethrowOutsideCatch(RethrowExpression node) {
     if (!_isInCatchClause) {
       _errorReporter.reportError2(CompileTimeErrorCode.RETHROW_OUTSIDE_CATCH, node, []);
       return true;
     }
     return false;
   }
 
   /**
    * This checks that if the given "target" is the type reference then the "name" is not the
    * reference to a instance member.
    * @param target the target of the name access to evaluate
    * @param name the accessed name to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticWarningCode#STATIC_ACCESS_TO_INSTANCE_MEMBER
    */
   bool checkForStaticAccessToInstanceMember(Expression target, SimpleIdentifier name2) {
-    Element element2 = name2.element;
-    if (element2 is! ExecutableElement) {
+    Element element = name2.element;
+    if (element is! ExecutableElement) {
       return false;
     }
-    ExecutableElement memberElement = element2 as ExecutableElement;
+    ExecutableElement memberElement = element as ExecutableElement;
     if (memberElement.isStatic()) {
       return false;
     }
     if (!isTypeReference(target)) {
       return false;
     }
     _errorReporter.reportError2(StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER, name2, [name2.name]);
     return true;
   }
 
   /**
    * This checks that the type of the passed 'switch' expression is assignable to the type of the
    * 'case' members.
    * @param node the 'switch' statement to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticWarningCode#SWITCH_EXPRESSION_NOT_ASSIGNABLE
    */
   bool checkForSwitchExpressionNotAssignable(SwitchStatement node) {
-    Expression expression2 = node.expression;
-    Type2 expressionType = getStaticType(expression2);
+    Expression expression = node.expression;
+    Type2 expressionType = getStaticType(expression);
     if (expressionType == null) {
       return false;
     }
-    NodeList<SwitchMember> members2 = node.members;
-    for (SwitchMember switchMember in members2) {
+    NodeList<SwitchMember> members = node.members;
+    for (SwitchMember switchMember in members) {
       if (switchMember is! SwitchCase) {
         continue;
       }
       SwitchCase switchCase = switchMember as SwitchCase;
       Expression caseExpression = switchCase.expression;
       Type2 caseType = getStaticType(caseExpression);
       if (expressionType.isAssignableTo(caseType)) {
         return false;
       }
-      _errorReporter.reportError2(StaticWarningCode.SWITCH_EXPRESSION_NOT_ASSIGNABLE, expression2, [expressionType, caseType]);
+      _errorReporter.reportError2(StaticWarningCode.SWITCH_EXPRESSION_NOT_ASSIGNABLE, expression, [expressionType, caseType]);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the type arguments in the passed instance creation expression are all within
    * their bounds as specified by the class element where the constructor \[that is being invoked\] is
    * declared.
    * @param node the instance creation expression to evaluate
@@ skipping 72 matching lines @@
   bool checkForWrongNumberOfParametersForOperator(MethodDeclaration node) {
     FormalParameterList parameterList = node.parameters;
     if (parameterList == null) {
       return false;
     }
     int numParameters = parameterList.parameters.length;
     SimpleIdentifier nameNode = node.name;
     if (nameNode == null) {
       return false;
     }
-    String name2 = nameNode.name;
+    String name = nameNode.name;
     int expected = -1;
-    if ("[]=" == name2) {
+    if ("[]=" == name) {
       expected = 2;
-    } else if ("<" == name2 || ">" == name2 || "<=" == name2 || ">=" == name2 || "==" == name2 || "+" == name2 || "/" == name2 || "~/" == name2 || "*" == name2 || "%" == name2 || "|" == name2 || "^" == name2 || "&" == name2 || "<<" == name2 || ">>" == name2 || "[]" == name2) {
+    } else if ("<" == name || ">" == name || "<=" == name || ">=" == name || "==" == name || "+" == name || "/" == name || "~/" == name || "*" == name || "%" == name || "|" == name || "^" == name || "&" == name || "<<" == name || ">>" == name || "[]" == name) {
       expected = 1;
-    } else if ("~" == name2) {
+    } else if ("~" == name) {
       expected = 0;
     }
     if (expected != -1 && numParameters != expected) {
-      _errorReporter.reportError2(CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR, nameNode, [name2, expected, numParameters]);
+      _errorReporter.reportError2(CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR, nameNode, [name, expected, numParameters]);
       return true;
     }
-    if ("-" == name2 && numParameters > 1) {
+    if ("-" == name && numParameters > 1) {
       _errorReporter.reportError2(CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR_MINUS, nameNode, [numParameters]);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies if the passed setter parameter list have only one parameter.
    * <p>
    * This method assumes that the method declaration was tested to be a setter before being called.
@@ skipping 79 matching lines @@
   }
 
   /**
    * Return the variable element represented by the given expression, or {@code null} if there is no
    * such element.
    * @param expression the expression whose element is to be returned
    * @return the variable element represented by the expression
    */
   VariableElement getVariableElement(Expression expression) {
     if (expression is Identifier) {
-      Element element2 = ((expression as Identifier)).element;
-      if (element2 is VariableElement) {
-        return element2 as VariableElement;
+      Element element = ((expression as Identifier)).element;
+      if (element is VariableElement) {
+        return element as VariableElement;
       }
     }
     return null;
   }
 
   /**
    * @return {@code true} if the given constructor redirects to itself, directly or indirectly
    */
   bool hasRedirectingFactoryConstructorCycle(ConstructorElement element) {
     Set<ConstructorElement> constructors = new Set<ConstructorElement>();
@@ skipping 130 matching lines @@
 
   /**
    * Answer the full name of the source associated with the compilation unit containing the given
    * AST node. The returned value will have all {@link File#separatorChar} replace by '/'.
    * @param node the node (not {@code null})
    * @return the full name or {@code null} if it could not be determined
    */
   String getSourceFullName(ASTNode node) {
     CompilationUnit unit = node.getAncestor(CompilationUnit);
     if (unit != null) {
-      CompilationUnitElement element2 = unit.element;
-      if (element2 != null) {
-        Source librarySource = element2.source;
+      CompilationUnitElement element = unit.element;
+      if (element != null) {
+        Source librarySource = element.source;
         if (librarySource != null) {
-          String fullName2 = librarySource.fullName;
-          if (fullName2 != null) {
-            return fullName2.replaceAll(r'\', '/');
+          String fullName = librarySource.fullName;
+          if (fullName != null) {
+            return fullName.replaceAll(r'\', '/');
           }
         }
       }
     }
     return null;
   }
 }
 /**
  * The enumeration {@code ResolverErrorCode} defines the error codes used for errors detected by the
  * resolver. The convention for this class is for the name of the error code to indicate the problem
@@ skipping 32 matching lines @@
     this._type = type;
     this._message = message;
   }
   ErrorSeverity get errorSeverity => _type.severity;
   String get message => _message;
   ErrorType get type => _type;
   int compareTo(ResolverErrorCode other) => ordinal - other.ordinal;
   int get hashCode => ordinal;
   String toString() => name;
 }