Generate unique names less aggressively.

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';
@@ skipping 21 matching lines @@
    */
   CompilationUnitBuilder() : super() {
   }
   /**
    * Build the compilation unit element for the given source.
    * @param source the source describing the compilation unit
    * @param unit the AST structure representing the compilation unit
    * @return the compilation unit element that was built
    * @throws AnalysisException if the analysis could not be performed
    */
-  CompilationUnitElementImpl buildCompilationUnit(Source source18, CompilationUnit unit) {
+  CompilationUnitElementImpl buildCompilationUnit(Source source2, CompilationUnit unit) {
     if (unit == null) {
       return null;
     }
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     unit.accept(builder);
-    CompilationUnitElementImpl element = new CompilationUnitElementImpl(source18.shortName);
+    CompilationUnitElementImpl element = new CompilationUnitElementImpl(source2.shortName);
     element.accessors = holder.accessors;
     element.functions = holder.functions;
-    element.source = source18;
+    element.source = source2;
     element.typeAliases = holder.typeAliases;
     element.types = holder.types;
     element.topLevelVariables = holder.topLevelVariables;
     unit.element = element;
     return element;
   }
 }
 /**
  * Instances of the class {@code ElementBuilder} traverse an AST structure and build the element
  * model representing the AST structure.
@@ skipping 47 matching lines @@
       }
     }
     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> typeVariables4 = holder.typeVariables;
+    List<TypeVariableElement> typeVariables2 = holder.typeVariables;
     InterfaceTypeImpl interfaceType = new InterfaceTypeImpl.con1(element);
-    interfaceType.typeArguments = createTypeVariableTypes(typeVariables4);
+    interfaceType.typeArguments = createTypeVariableTypes(typeVariables2);
     element.type = interfaceType;
-    List<ConstructorElement> constructors3 = holder.constructors;
-    if (constructors3.length == 0) {
+    List<ConstructorElement> constructors2 = holder.constructors;
+    if (constructors2.length == 0) {
       ConstructorElementImpl constructor = new ConstructorElementImpl(null);
       constructor.synthetic = true;
       FunctionTypeImpl type = new FunctionTypeImpl.con1(constructor);
       type.returnType = interfaceType;
       constructor.type = type;
-      constructors3 = <ConstructorElement> [constructor];
+      constructors2 = <ConstructorElement> [constructor];
     }
     element.abstract = node.abstractKeyword != null;
     element.accessors = holder.accessors;
-    element.constructors = constructors3;
+    element.constructors = constructors2;
     element.fields = holder.fields;
     element.methods = holder.methods;
-    element.typeVariables = typeVariables4;
+    element.typeVariables = typeVariables2;
     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> typeVariables5 = holder.typeVariables;
-    element.typeVariables = typeVariables5;
+    List<TypeVariableElement> typeVariables2 = holder.typeVariables;
+    element.typeVariables = typeVariables2;
     InterfaceTypeImpl interfaceType = new InterfaceTypeImpl.con1(element);
-    interfaceType.typeArguments = createTypeVariableTypes(typeVariables5);
+    interfaceType.typeArguments = createTypeVariableTypes(typeVariables2);
     element.type = 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 returnType4 = node.returnType;
-      if (returnType4 != null) {
-        element.nameOffset = returnType4.offset;
+      Identifier returnType2 = node.returnType;
+      if (returnType2 != null) {
+        element.nameOffset = returnType2.offset;
       }
     } else {
       constructorName.element = element;
     }
     return null;
   }
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     SimpleIdentifier variableName = node.identifier;
-    sc.Token keyword28 = node.keyword;
+    sc.Token keyword2 = 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(keyword28, sc.Keyword.CONST);
-    element.final2 = matches(keyword28, sc.Keyword.FINAL);
+    element.const3 = matches(keyword2, sc.Keyword.CONST);
+    element.final2 = matches(keyword2, 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 132 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> parameters11 = holder.parameters;
-    List<TypeVariableElement> typeVariables6 = holder.typeVariables;
+    List<ParameterElement> parameters2 = holder.parameters;
+    List<TypeVariableElement> typeVariables2 = holder.typeVariables;
     FunctionTypeAliasElementImpl element = new FunctionTypeAliasElementImpl(aliasName);
-    element.parameters = parameters11;
-    element.typeVariables = typeVariables6;
+    element.parameters = parameters2;
+    element.typeVariables = typeVariables2;
     FunctionTypeImpl type = new FunctionTypeImpl.con2(element);
-    type.typeArguments = createTypeVariableTypes(typeVariables6);
+    type.typeArguments = createTypeVariableTypes(typeVariables2);
     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 113 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 keyword29 = ((node.parent as VariableDeclarationList)).keyword;
-    bool isConst = matches(keyword29, sc.Keyword.CONST);
-    bool isFinal = matches(keyword29, sc.Keyword.FINAL);
+    sc.Token keyword2 = ((node.parent as VariableDeclarationList)).keyword;
+    bool isConst = matches(keyword2, sc.Keyword.CONST);
+    bool isFinal = matches(keyword2, 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 74 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 parent13 = node.parent;
-    while (parent13 != null) {
-      if (parent13 is FunctionExpression) {
-        return ((parent13 as FunctionExpression)).body;
-      } else if (parent13 is MethodDeclaration) {
-        return ((parent13 as MethodDeclaration)).body;
+    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;
       }
-      parent13 = parent13.parent;
+      parent2 = parent2.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
    */
-  bool matches(sc.Token token, sc.Keyword keyword37) => token != null && identical(token.type, sc.TokenType.KEYWORD) && identical(((token as sc.KeywordToken)).keyword, keyword37);
+  bool matches(sc.Token token, sc.Keyword keyword2) => token != null && identical(token.type, sc.TokenType.KEYWORD) && identical(((token as sc.KeywordToken)).keyword, keyword2);
   /**
    * Make the given holder be the current holder while visiting the given node.
    * @param holder the holder that will gather elements that are built while visiting the children
    * @param node the node to be visited
    */
   void visit(ElementHolder holder, ASTNode node) {
     if (node != null) {
       ElementHolder previousHolder = _currentHolder;
       _currentHolder = holder;
       try {
@@ skipping 194 matching lines @@
    * @return the HTML element that was built
    * @throws AnalysisException if the analysis could not be performed
    */
   HtmlElementImpl buildHtmlElement(Source source) => buildHtmlElement2(source, _context.parseHtmlUnit(source));
   /**
    * Build the HTML element for the given source.
    * @param source the source describing the compilation unit
    * @param unit the AST structure representing the HTML
    * @throws AnalysisException if the analysis could not be performed
    */
-  HtmlElementImpl buildHtmlElement2(Source source19, ht.HtmlUnit unit) {
-    HtmlElementImpl result = new HtmlElementImpl(_context, source19.shortName);
-    result.source = source19;
+  HtmlElementImpl buildHtmlElement2(Source source2, ht.HtmlUnit unit) {
+    HtmlElementImpl result = new HtmlElementImpl(_context, source2.shortName);
+    result.source = source2;
     _htmlElement = result;
     unit.accept(this);
     _htmlElement = null;
     unit.element = result;
     return result;
   }
   Object visitHtmlUnit(ht.HtmlUnit node) {
     _scripts = new List<HtmlScriptElement>();
     node.visitChildren(this);
     _htmlElement.scripts = new List.from(_scripts);
@@ skipping 110 matching lines @@
    * Initialize a newly created resolver.
    */
   DeclarationResolver() : super() {
   }
   /**
    * Resolve the declarations within the given compilation unit to the elements rooted at the given
    * 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 element67) {
-    _enclosingUnit = element67;
-    unit.element = element67;
+  void resolve(CompilationUnit unit, CompilationUnitElement element2) {
+    _enclosingUnit = element2;
+    unit.element = element2;
     unit.accept(this);
   }
   Object visitCatchClause(CatchClause node) {
-    SimpleIdentifier exceptionParameter3 = node.exceptionParameter;
-    if (exceptionParameter3 != null) {
-      List<LocalVariableElement> localVariables3 = _enclosingExecutable.localVariables;
-      find3(localVariables3, exceptionParameter3);
-      SimpleIdentifier stackTraceParameter3 = node.stackTraceParameter;
-      if (stackTraceParameter3 != null) {
-        find3(localVariables3, stackTraceParameter3);
+    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);
       }
     }
     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 parent14 = node.parent;
-      while (parent14 != null) {
-        writer.println(parent14.runtimeType.toString());
+      ASTNode parent2 = node.parent;
+      while (parent2 != null) {
+        writer.println(parent2.runtimeType.toString());
         writer.println("---------");
-        parent14 = parent14.parent;
+        parent2 = parent2.parent;
       }
       AnalysisEngine.instance.logger.logError2(writer.toString(), new AnalysisException());
     }
     Expression defaultValue2 = node.defaultValue;
     if (defaultValue2 != null) {
       ExecutableElement outerExecutable = _enclosingExecutable;
       try {
         if (element == null) {
         } else {
           _enclosingExecutable = element.initializer;
         }
         defaultValue2.accept(this);
       } finally {
         _enclosingExecutable = outerExecutable;
       }
     }
     ParameterElement outerParameter = _enclosingParameter;
     try {
       _enclosingParameter = element;
       return super.visitDefaultFormalParameter(node);
     } finally {
       _enclosingParameter = outerParameter;
     }
   }
   Object visitExportDirective(ExportDirective node) {
-    String uri3 = getStringValue(node.uri);
-    if (uri3 != null) {
-      LibraryElement library31 = _enclosingUnit.library;
-      ExportElement exportElement = find5(library31.exports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri3));
+    String uri2 = getStringValue(node.uri);
+    if (uri2 != null) {
+      LibraryElement library2 = _enclosingUnit.library;
+      ExportElement exportElement = find5(library2.exports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri2));
       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 uri4 = getStringValue(node.uri);
-    if (uri4 != null) {
-      LibraryElement library32 = _enclosingUnit.library;
-      ImportElement importElement = find6(library32.imports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri4), node.prefix);
+    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);
       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 uri5 = getStringValue(node.uri);
-    if (uri5 != null) {
-      Source partSource = _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri5);
+    String uri2 = getStringValue(node.uri);
+    if (uri2 != null) {
+      Source partSource = _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri2);
       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 initializer5 = node.initializer;
-    if (initializer5 != null) {
+    Expression initializer2 = node.initializer;
+    if (initializer2 != null) {
       ExecutableElement outerExecutable = _enclosingExecutable;
       try {
         if (element == null) {
         } else {
           _enclosingExecutable = element.initializer;
         }
         return super.visitVariableDeclaration(node);
       } finally {
         _enclosingExecutable = outerExecutable;
       }
@@ skipping 54 matching lines @@
     return element;
   }
   /**
    * Return the element in the given array of elements that was created for the declaration with the
    * given name at the given offset.
    * @param elements the elements of the appropriate kind that exist in the current context
    * @param name the name of the element to be returned
    * @param offset the offset of the name of the element to be returned
    * @return the element with the given name and offset
    */
-  Element find4(List<Element> elements, String name30, int offset) {
+  Element find4(List<Element> elements, String name2, int offset) {
     for (Element element in elements) {
-      if (element.name == name30 && element.nameOffset == offset) {
+      if (element.name == name2 && element.nameOffset == offset) {
         return element;
       }
     }
     return null;
   }
   /**
    * Return the export element from the given array whose library has the given source, or{@code null} if there is no such export.
    * @param exports the export elements being searched
    * @param source the source of the library associated with the export element to being searched
    * for
    * @return the export element whose library has the given source
    */
-  ExportElement find5(List<ExportElement> exports, Source source21) {
+  ExportElement find5(List<ExportElement> exports, Source source2) {
     for (ExportElement export in exports) {
-      if (export.exportedLibrary.source == source21) {
+      if (export.exportedLibrary.source == source2) {
         return export;
       }
     }
     return null;
   }
   /**
    * Return the import element from the given array whose library has the given source and that has
    * the given prefix, or {@code null} if there is no such import.
    * @param imports the import elements being searched
    * @param source the source of the library associated with the import element to being searched
    * for
    * @param prefix the prefix with which the library was imported
    * @return the import element whose library has the given source and prefix
    */
-  ImportElement find6(List<ImportElement> imports, Source source22, SimpleIdentifier prefix12) {
+  ImportElement find6(List<ImportElement> imports, Source source2, SimpleIdentifier prefix2) {
     for (ImportElement element in imports) {
-      if (element.importedLibrary.source == source22) {
+      if (element.importedLibrary.source == source2) {
         PrefixElement prefixElement = element.prefix;
-        if (prefix12 == null) {
+        if (prefix2 == null) {
           if (prefixElement == null) {
             return element;
           }
         } else {
-          if (prefixElement != null && prefix12.name == prefixElement.name) {
+          if (prefixElement != null && prefix2.name == prefixElement.name) {
             return element;
           }
         }
       }
     }
     return null;
   }
   /**
    * Return the value of the given string literal, or {@code null} if the string is not a constant
    * string without any string interpolation.
@@ skipping 66 matching lines @@
    */
   ResolverVisitor _resolver;
   /**
    * 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;
   }
   Object visitAssignmentExpression(AssignmentExpression node) {
-    sc.TokenType operator7 = node.operator.type;
-    if (operator7 != sc.TokenType.EQ) {
-      operator7 = operatorFromCompoundAssignment(operator7);
+    sc.TokenType operator2 = node.operator.type;
+    if (operator2 != sc.TokenType.EQ) {
+      operator2 = operatorFromCompoundAssignment(operator2);
       Expression leftNode = node.leftHandSide;
       if (leftNode != null) {
         Type2 leftType = getType(leftNode);
         if (leftType != null) {
-          MethodElement method = lookUpMethod(leftType, operator7.lexeme);
+          MethodElement method = lookUpMethod(leftType, operator2.lexeme);
           if (method != null) {
             node.element = method;
           } else {
           }
         }
       }
     }
     return null;
   }
   Object visitBinaryExpression(BinaryExpression node) {
-    sc.Token operator8 = node.operator;
-    if (operator8.isUserDefinableOperator()) {
+    sc.Token operator2 = node.operator;
+    if (operator2.isUserDefinableOperator()) {
       Type2 leftType = getType(node.leftOperand);
       if (leftType == null || leftType.isDynamic()) {
         return null;
       } else if (leftType is FunctionType) {
         leftType = _resolver.typeProvider.functionType;
       }
-      String methodName = operator8.lexeme;
+      String methodName = operator2.lexeme;
       MethodElement member = lookUpMethod(leftType, methodName);
       if (member == null) {
-        _resolver.reportError3(StaticWarningCode.UNDEFINED_OPERATOR, operator8, [methodName, leftType.name]);
+        _resolver.reportError3(StaticWarningCode.UNDEFINED_OPERATOR, operator2, [methodName, leftType.name]);
       } else {
         node.element = member;
       }
     }
     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 visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     FieldElement fieldElement = null;
     SimpleIdentifier fieldName2 = node.fieldName;
     ClassElement enclosingClass2 = _resolver.enclosingClass;
     fieldElement = ((enclosingClass2 as ClassElementImpl)).getField(fieldName2.name);
     if (fieldElement != null && !fieldElement.isSynthetic()) {
       recordResolution(fieldName2, fieldElement);
     }
     return null;
   }
   Object visitConstructorName(ConstructorName node) {
-    Type2 type14 = node.type.type;
-    if (type14 is DynamicTypeImpl) {
+    Type2 type2 = node.type.type;
+    if (type2 is DynamicTypeImpl) {
       return null;
-    } else if (type14 is! InterfaceType) {
-      ASTNode parent15 = node.parent;
-      if (parent15 is InstanceCreationExpression) {
-        if (((parent15 as InstanceCreationExpression)).isConst()) {
+    } else if (type2 is! InterfaceType) {
+      ASTNode parent2 = node.parent;
+      if (parent2 is InstanceCreationExpression) {
+        if (((parent2 as InstanceCreationExpression)).isConst()) {
         } else {
         }
       } else {
       }
       return null;
     }
-    ClassElement classElement = ((type14 as InterfaceType)).element;
+    ClassElement classElement = ((type2 as InterfaceType)).element;
     ConstructorElement constructor;
-    SimpleIdentifier name17 = node.name;
-    if (name17 == null) {
+    SimpleIdentifier name2 = node.name;
+    if (name2 == null) {
       constructor = classElement.unnamedConstructor;
     } else {
-      constructor = classElement.getNamedConstructor(name17.name);
-      name17.element = constructor;
+      constructor = classElement.getNamedConstructor(name2.name);
+      name2.element = 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 visitExportDirective(ExportDirective node) {
-    Element element28 = node.element;
-    if (element28 is ExportElement) {
-      resolveCombinators(((element28 as ExportElement)).exportedLibrary, node.combinators);
+    Element element2 = node.element;
+    if (element2 is ExportElement) {
+      resolveCombinators(((element2 as ExportElement)).exportedLibrary, node.combinators);
     }
     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) {
         if (!fieldElement.isSynthetic()) {
@@ skipping 16 matching lines @@
     SimpleIdentifier prefixNode = node.prefix;
     if (prefixNode != null) {
       String prefixName = prefixNode.name;
       for (PrefixElement prefixElement in _resolver.definingLibrary.prefixes) {
         if (prefixElement.name == prefixName) {
           recordResolution(prefixNode, prefixElement);
           break;
         }
       }
     }
-    Element element29 = node.element;
-    if (element29 is ImportElement) {
-      resolveCombinators(((element29 as ImportElement)).importedLibrary, node.combinators);
+    Element element2 = node.element;
+    if (element2 is ImportElement) {
+      resolveCombinators(((element2 as ImportElement)).importedLibrary, node.combinators);
     }
     return null;
   }
   Object visitIndexExpression(IndexExpression node) {
     Type2 arrayType = getType(node.realTarget);
     if (arrayType == null || arrayType.isDynamic()) {
       return null;
     }
     String operator;
     if (node.inSetterContext()) {
@@ skipping 15 matching lines @@
     resolveNamedArguments(node.argumentList, invokedConstructor);
     return null;
   }
   Object visitMethodInvocation(MethodInvocation node) {
     SimpleIdentifier methodName2 = node.methodName;
     Expression target = node.realTarget;
     Element element;
     if (target == null) {
       element = _resolver.nameScope.lookup(methodName2, _resolver.definingLibrary);
       if (element == null) {
-        ClassElement enclosingClass3 = _resolver.enclosingClass;
-        if (enclosingClass3 != null) {
-          InterfaceType enclosingType = enclosingClass3.type;
+        ClassElement enclosingClass2 = _resolver.enclosingClass;
+        if (enclosingClass2 != null) {
+          InterfaceType enclosingType = enclosingClass2.type;
           element = lookUpMethod(enclosingType, methodName2.name);
           if (element == null) {
             PropertyAccessorElement getter = lookUpGetter(enclosingType, methodName2.name);
             if (getter != null) {
               FunctionType getterType = getter.type;
               if (getterType != null) {
-                Type2 returnType5 = getterType.returnType;
-                if (!isExecutableType(returnType5)) {
+                Type2 returnType2 = getterType.returnType;
+                if (!isExecutableType(returnType2)) {
                   _resolver.reportError(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName2, [methodName2.name]);
                 }
               }
               recordResolution(methodName2, getter);
               return null;
             }
           }
         }
       }
     } else {
       Type2 targetType = getType(target);
       if (targetType is InterfaceType) {
         InterfaceType classType = targetType as InterfaceType;
         element = lookUpMethod(classType, methodName2.name);
         if (element == null) {
           PropertyAccessorElement accessor = classType.getGetter(methodName2.name);
           if (accessor != null) {
-            Type2 returnType6 = accessor.type.returnType;
-            if (!isExecutableType(returnType6)) {
+            Type2 returnType3 = accessor.type.returnType;
+            if (!isExecutableType(returnType3)) {
               _resolver.reportError(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName2, [methodName2.name]);
               return null;
             }
             element = accessor;
           }
         }
         if (element == null && target is SuperExpression) {
           _resolver.reportError(StaticTypeWarningCode.UNDEFINED_SUPER_METHOD, methodName2, [methodName2.name, targetType.element.name]);
           return null;
         }
       } else if (target is SimpleIdentifier) {
         Element targetElement = ((target as SimpleIdentifier)).element;
         if (targetElement is PrefixElement) {
-          String name10 = "${((target as SimpleIdentifier)).name}.${methodName2}";
-          Identifier functionName = new Identifier_8(name10);
+          String name3 = "${((target as SimpleIdentifier)).name}.${methodName2}";
+          Identifier functionName = new Identifier_8(name3);
           element = _resolver.nameScope.lookup(functionName, _resolver.definingLibrary);
         } else {
           return null;
         }
       } else {
         return null;
       }
     }
     ExecutableElement invokedMethod = null;
     if (element is PropertyAccessorElement) {
       PropertyAccessorElement getter = element as PropertyAccessorElement;
       FunctionType getterType = getter.type;
       if (getterType != null) {
-        Type2 returnType7 = getterType.returnType;
-        if (!isExecutableType(returnType7)) {
+        Type2 returnType4 = getterType.returnType;
+        if (!isExecutableType(returnType4)) {
           _resolver.reportError(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName2, [methodName2.name]);
         }
       }
       recordResolution(methodName2, element);
       return null;
     } else if (element is ExecutableElement) {
       invokedMethod = element as ExecutableElement;
     } else {
       if (element is PropertyInducingElement) {
-        PropertyAccessorElement getter3 = ((element as PropertyInducingElement)).getter;
-        FunctionType getterType = getter3.type;
+        PropertyAccessorElement getter2 = ((element as PropertyInducingElement)).getter;
+        FunctionType getterType = getter2.type;
         if (getterType != null) {
-          Type2 returnType8 = getterType.returnType;
-          if (!isExecutableType(returnType8)) {
+          Type2 returnType5 = getterType.returnType;
+          if (!isExecutableType(returnType5)) {
             _resolver.reportError(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName2, [methodName2.name]);
           }
         }
         recordResolution(methodName2, element);
         return null;
       } else if (element is VariableElement) {
         Type2 variableType = _resolver.overrideManager.getType(element);
         if (variableType == null) {
           variableType = ((element as VariableElement)).type;
         }
         if (!isExecutableType(variableType)) {
           _resolver.reportError(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName2, [methodName2.name]);
         }
         recordResolution(methodName2, element);
         return null;
       } else {
         if (target == null) {
-          ClassElement enclosingClass4 = _resolver.enclosingClass;
-          if (enclosingClass4 == null) {
+          ClassElement enclosingClass3 = _resolver.enclosingClass;
+          if (enclosingClass3 == null) {
             _resolver.reportError(StaticTypeWarningCode.UNDEFINED_FUNCTION, methodName2, [methodName2.name]);
           } else if (element == null) {
-            _resolver.reportError(StaticTypeWarningCode.UNDEFINED_METHOD, methodName2, [methodName2.name, enclosingClass4.name]);
+            _resolver.reportError(StaticTypeWarningCode.UNDEFINED_METHOD, methodName2, [methodName2.name, enclosingClass3.name]);
           } else {
             _resolver.reportError(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName2, [methodName2.name]);
           }
         } else {
           Type2 targetType = getType(target);
           String targetTypeName = targetType == null ? null : targetType.name;
           if (targetTypeName == null) {
             _resolver.reportError(StaticTypeWarningCode.UNDEFINED_FUNCTION, methodName2, [methodName2.name]);
           } else {
             _resolver.reportError(StaticTypeWarningCode.UNDEFINED_METHOD, methodName2, [methodName2.name, targetTypeName]);
           }
         }
         return null;
       }
     }
     recordResolution(methodName2, invokedMethod);
     resolveNamedArguments(node.argumentList, invokedMethod);
     return null;
   }
   Object visitPostfixExpression(PostfixExpression node) {
-    sc.Token operator9 = node.operator;
+    sc.Token operator2 = node.operator;
     Type2 operandType = getType(node.operand);
     if (operandType == null || operandType.isDynamic()) {
       return null;
     }
     String methodName;
-    if (identical(operator9.type, sc.TokenType.PLUS_PLUS)) {
+    if (identical(operator2.type, sc.TokenType.PLUS_PLUS)) {
       methodName = sc.TokenType.PLUS.lexeme;
     } else {
       methodName = sc.TokenType.MINUS.lexeme;
     }
     MethodElement member = lookUpMethod(operandType, methodName);
     if (member == null) {
-      _resolver.reportError3(StaticWarningCode.UNDEFINED_OPERATOR, operator9, [methodName, operandType.name]);
+      _resolver.reportError3(StaticWarningCode.UNDEFINED_OPERATOR, operator2, [methodName, operandType.name]);
     } else {
       node.element = member;
     }
     return null;
   }
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
-    SimpleIdentifier prefix6 = node.prefix;
-    SimpleIdentifier identifier14 = node.identifier;
-    Element prefixElement = prefix6.element;
+    SimpleIdentifier prefix2 = node.prefix;
+    SimpleIdentifier identifier2 = node.identifier;
+    Element prefixElement = prefix2.element;
     if (prefixElement is PrefixElement) {
       Element element = _resolver.nameScope.lookup(node, _resolver.definingLibrary);
       if (element == null) {
         return null;
       }
-      recordResolution(identifier14, element);
+      recordResolution(identifier2, element);
       return null;
     }
     if (prefixElement is ClassElement) {
       Element memberElement;
       if (node.identifier.inSetterContext()) {
-        memberElement = ((prefixElement as ClassElementImpl)).getSetter(identifier14.name);
+        memberElement = ((prefixElement as ClassElementImpl)).getSetter(identifier2.name);
       } else {
-        memberElement = ((prefixElement as ClassElementImpl)).getGetter(identifier14.name);
+        memberElement = ((prefixElement as ClassElementImpl)).getGetter(identifier2.name);
       }
       if (memberElement == null) {
-        MethodElement methodElement = lookUpMethod(((prefixElement as ClassElement)).type, identifier14.name);
+        MethodElement methodElement = lookUpMethod(((prefixElement as ClassElement)).type, identifier2.name);
         if (methodElement != null) {
-          recordResolution(identifier14, methodElement);
+          recordResolution(identifier2, methodElement);
           return null;
         }
       }
       if (memberElement == null) {
-        reportGetterOrSetterNotFound(node, identifier14, prefixElement.name);
+        reportGetterOrSetterNotFound(node, identifier2, prefixElement.name);
       } else {
-        recordResolution(identifier14, memberElement);
+        recordResolution(identifier2, memberElement);
       }
       return null;
     }
     Type2 variableType;
     if (prefixElement is PropertyAccessorElement) {
       PropertyAccessorElement accessor = prefixElement as PropertyAccessorElement;
-      FunctionType type15 = accessor.type;
-      if (type15 == null) {
+      FunctionType type2 = accessor.type;
+      if (type2 == null) {
         return null;
       }
       if (accessor.isGetter()) {
-        variableType = type15.returnType;
+        variableType = type2.returnType;
       } else {
-        variableType = type15.normalParameterTypes[0];
+        variableType = type2.normalParameterTypes[0];
       }
       if (variableType == null || variableType.isDynamic()) {
         return null;
       }
     } else if (prefixElement is VariableElement) {
       variableType = _resolver.overrideManager.getType(prefixElement);
       if (variableType == null) {
         variableType = ((prefixElement as VariableElement)).type;
       }
       if (variableType == null || variableType.isDynamic()) {
         return null;
       }
     } else {
       return null;
     }
     PropertyAccessorElement memberElement = null;
     if (node.identifier.inSetterContext()) {
-      memberElement = lookUpSetter(variableType, identifier14.name);
+      memberElement = lookUpSetter(variableType, identifier2.name);
     }
     if (memberElement == null && node.identifier.inGetterContext()) {
-      memberElement = lookUpGetter(variableType, identifier14.name);
+      memberElement = lookUpGetter(variableType, identifier2.name);
     }
     if (memberElement == null) {
-      MethodElement methodElement = lookUpMethod(variableType, identifier14.name);
+      MethodElement methodElement = lookUpMethod(variableType, identifier2.name);
       if (methodElement != null) {
-        recordResolution(identifier14, methodElement);
+        recordResolution(identifier2, methodElement);
         return null;
       }
     }
     if (memberElement == null) {
-      reportGetterOrSetterNotFound(node, identifier14, variableType.element.name);
+      reportGetterOrSetterNotFound(node, identifier2, variableType.element.name);
     } else {
-      recordResolution(identifier14, memberElement);
+      recordResolution(identifier2, memberElement);
     }
     return null;
   }
   Object visitPrefixExpression(PrefixExpression node) {
-    sc.Token operator10 = node.operator;
-    sc.TokenType operatorType = operator10.type;
+    sc.Token operator2 = node.operator;
+    sc.TokenType operatorType = operator2.type;
     if (operatorType.isUserDefinableOperator() || identical(operatorType, sc.TokenType.PLUS_PLUS) || identical(operatorType, sc.TokenType.MINUS_MINUS)) {
       Type2 operandType = getType(node.operand);
       if (operandType == null || operandType.isDynamic()) {
         return null;
       }
       String methodName;
       if (identical(operatorType, sc.TokenType.PLUS_PLUS)) {
         methodName = sc.TokenType.PLUS.lexeme;
       } else if (identical(operatorType, sc.TokenType.MINUS_MINUS)) {
         methodName = sc.TokenType.MINUS.lexeme;
       } else if (identical(operatorType, sc.TokenType.MINUS)) {
         methodName = "unary-";
       } else {
-        methodName = operator10.lexeme;
+        methodName = operator2.lexeme;
       }
       MethodElement member = lookUpMethod(operandType, methodName);
       if (member == null) {
-        _resolver.reportError3(StaticWarningCode.UNDEFINED_OPERATOR, operator10, [methodName, operandType.name]);
+        _resolver.reportError3(StaticWarningCode.UNDEFINED_OPERATOR, operator2, [methodName, operandType.name]);
       } else {
         node.element = member;
       }
     }
     return null;
   }
   Object visitPropertyAccess(PropertyAccess node) {
     Type2 targetType = getType(node.realTarget);
     if (targetType is! InterfaceType) {
       return null;
@@ skipping 20 matching lines @@
         _resolver.reportError(StaticWarningCode.UNDEFINED_GETTER, identifier, [identifier.name, targetType.name]);
       } else {
         _resolver.reportError(StaticWarningCode.UNDEFINED_IDENTIFIER, identifier, [identifier.name]);
       }
     } else {
       recordResolution(identifier, memberElement);
     }
     return null;
   }
   Object visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
-    ClassElement enclosingClass5 = _resolver.enclosingClass;
-    if (enclosingClass5 == null) {
+    ClassElement enclosingClass2 = _resolver.enclosingClass;
+    if (enclosingClass2 == null) {
       return null;
     }
     SimpleIdentifier name = node.constructorName;
     ConstructorElement element;
     if (name == null) {
-      element = enclosingClass5.unnamedConstructor;
+      element = enclosingClass2.unnamedConstructor;
     } else {
-      element = enclosingClass5.getNamedConstructor(name.name);
+      element = enclosingClass2.getNamedConstructor(name.name);
     }
     if (element == null) {
       return null;
     }
     if (name != null) {
       recordResolution(name, element);
     }
     node.element = element;
     resolveNamedArguments(node.argumentList, element);
     return null;
   }
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (node.element != null) {
       return null;
     }
     Element element = _resolver.nameScope.lookup(node, _resolver.definingLibrary);
     if (element is PropertyAccessorElement && node.inSetterContext()) {
-      PropertyInducingElement variable5 = ((element as PropertyAccessorElement)).variable;
-      if (variable5 != null) {
-        PropertyAccessorElement setter3 = variable5.setter;
-        if (setter3 != null) {
-          element = setter3;
+      PropertyInducingElement variable2 = ((element as PropertyAccessorElement)).variable;
+      if (variable2 != null) {
+        PropertyAccessorElement setter2 = variable2.setter;
+        if (setter2 != null) {
+          element = setter2;
         }
       }
     }
-    ClassElement enclosingClass6 = _resolver.enclosingClass;
-    if (element == null && enclosingClass6 != null) {
-      InterfaceType enclosingType = enclosingClass6.type;
+    ClassElement enclosingClass2 = _resolver.enclosingClass;
+    if (element == null && enclosingClass2 != null) {
+      InterfaceType enclosingType = enclosingClass2.type;
       if (element == null && node.inSetterContext()) {
         element = lookUpSetter(enclosingType, node.name);
       }
       if (element == null && node.inGetterContext()) {
         element = lookUpGetter(enclosingType, node.name);
       }
       if (element == null) {
         element = lookUpMethod(enclosingType, node.name);
       }
     }
     if (element == null) {
       _resolver.reportError(StaticWarningCode.UNDEFINED_IDENTIFIER, node, [node.name]);
     }
     recordResolution(node, element);
     return null;
   }
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
-    ClassElement enclosingClass7 = _resolver.enclosingClass;
-    if (enclosingClass7 == null) {
+    ClassElement enclosingClass2 = _resolver.enclosingClass;
+    if (enclosingClass2 == null) {
       return null;
     }
-    ClassElement superclass = getSuperclass(enclosingClass7);
+    ClassElement superclass = getSuperclass(enclosingClass2);
     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) {
       return null;
     }
     if (name != null) {
       recordResolution(name, element);
     }
     node.element = element;
     resolveNamedArguments(node.argumentList, element);
     return null;
   }
   Object visitTypeParameter(TypeParameter node) {
-    TypeName bound3 = node.bound;
-    if (bound3 != null) {
+    TypeName bound2 = node.bound;
+    if (bound2 != null) {
       TypeVariableElementImpl variable = node.name.element as TypeVariableElementImpl;
       if (variable != null) {
-        variable.bound = bound3.type;
+        variable.bound = bound2.type;
       }
     }
     return null;
   }
   /**
    * Search through the array of parameters for a parameter whose name matches the given name.
    * Return the parameter with the given name, or {@code null} if there is no such parameter.
    * @param parameters the parameters being searched
    * @param name the name being searched for
    * @return the parameter with the given name
    */
-  ParameterElement findNamedParameter(List<ParameterElement> parameters, String name31) {
+  ParameterElement findNamedParameter(List<ParameterElement> parameters, String name2) {
     for (ParameterElement parameter in parameters) {
       if (identical(parameter.parameterKind, ParameterKind.NAMED)) {
         String parameteName = parameter.name;
-        if (parameteName != null && parameteName == name31) {
+        if (parameteName != null && parameteName == name2) {
           return parameter;
         }
       }
     }
     return null;
   }
   /**
    * 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
@@ skipping 69 matching lines @@
     PropertyAccessorElement getter = targetType.getGetter(getterName);
     if (getter != null) {
       return getter;
     }
     for (InterfaceType interfaceType in targetType.interfaces) {
       getter = lookUpGetterInInterfaces(interfaceType, getterName, visitedInterfaces);
       if (getter != null) {
         return getter;
       }
     }
-    InterfaceType superclass3 = targetType.superclass;
-    if (superclass3 == null) {
+    InterfaceType superclass2 = targetType.superclass;
+    if (superclass2 == null) {
       return null;
     }
-    return lookUpGetterInInterfaces(superclass3, getterName, visitedInterfaces);
+    return lookUpGetterInInterfaces(superclass2, getterName, 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;
     LabelElementImpl labelElement = null;
@@ skipping 63 matching lines @@
     MethodElement method = targetType.getMethod(methodName);
     if (method != null) {
       return method;
     }
     for (InterfaceType interfaceType in targetType.interfaces) {
       method = lookUpMethodInInterfaces(interfaceType, methodName, visitedInterfaces);
       if (method != null) {
         return method;
       }
     }
-    InterfaceType superclass4 = targetType.superclass;
-    if (superclass4 == null) {
+    InterfaceType superclass2 = targetType.superclass;
+    if (superclass2 == null) {
       return null;
     }
-    return lookUpMethodInInterfaces(superclass4, methodName, visitedInterfaces);
+    return lookUpMethodInInterfaces(superclass2, 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 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
    */
   PropertyAccessorElement lookUpSetter(Type2 type, String setterName) {
     type = resolveTypeVariable(type);
@@ skipping 25 matching lines @@
     PropertyAccessorElement setter = targetType.getGetter(setterName);
     if (setter != null) {
       return setter;
     }
     for (InterfaceType interfaceType in targetType.interfaces) {
       setter = lookUpSetterInInterfaces(interfaceType, setterName, visitedInterfaces);
       if (setter != null) {
         return setter;
       }
     }
-    InterfaceType superclass5 = targetType.superclass;
-    if (superclass5 == null) {
+    InterfaceType superclass2 = targetType.superclass;
+    if (superclass2 == null) {
       return null;
     }
-    return lookUpSetterInInterfaces(superclass5, setterName, visitedInterfaces);
+    return lookUpSetterInInterfaces(superclass2, 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) {
         return sc.TokenType.AMPERSAND;
@@ skipping 21 matching lines @@
       break;
     }
     AnalysisEngine.instance.logger.logError("Failed to map ${operator.lexeme} to it's corresponding operator");
     return operator;
   }
   /**
    * Record the fact that the given AST node was resolved to the given element.
    * @param node the AST node that was resolved
    * @param element the element to which the AST node was resolved
    */
-  void recordResolution(SimpleIdentifier node, Element element68) {
-    if (element68 != null) {
-      node.element = element68;
+  void recordResolution(SimpleIdentifier node, Element element2) {
+    if (element2 != null) {
+      node.element = element2;
     }
   }
   /**
    * Report the {@link StaticTypeWarningCode}s <code>UNDEFINED_SETTER</code> and
    * <code>UNDEFINED_GETTER</code>.
    * @param node the prefixed identifier that gives the context to determine if the error on the
    * undefined identifier is a getter or a setter
    * @param identifier the identifier in the passed prefix identifier
    * @param typeName the name of the type of the left hand side of the passed prefixed identifier
    */
-  void reportGetterOrSetterNotFound(PrefixedIdentifier node, SimpleIdentifier identifier32, String typeName) {
+  void reportGetterOrSetterNotFound(PrefixedIdentifier node, SimpleIdentifier identifier2, String typeName) {
     bool isSetterContext = node.identifier.inSetterContext();
     ErrorCode errorCode = isSetterContext ? StaticTypeWarningCode.UNDEFINED_SETTER : StaticTypeWarningCode.UNDEFINED_GETTER;
-    _resolver.reportError(errorCode, identifier32, [identifier32.name, typeName]);
+    _resolver.reportError(errorCode, identifier2, [identifier2.name, typeName]);
   }
   /**
    * Resolve the names in the given combinators in the scope of the given library.
    * @param library the library that defines the names
    * @param combinators the combinators containing the names to be resolved
    */
   void resolveCombinators(LibraryElement library, NodeList<Combinator> combinators) {
     if (library == null) {
       return;
     }
@@ skipping 17 matching lines @@
    * Resolve the names associated with any named arguments to the parameter elements named by the
    * argument.
    * @param argumentList the arguments to be resolved
    * @param invokedMethod the method or function defining the parameters to which the named
    * arguments are to be resolved
    */
   void resolveNamedArguments(ArgumentList argumentList, ExecutableElement invokedMethod) {
     if (invokedMethod == null) {
       return;
     }
-    List<ParameterElement> parameters13 = invokedMethod.parameters;
+    List<ParameterElement> parameters2 = invokedMethod.parameters;
     for (Expression argument in argumentList.arguments) {
       if (argument is NamedExpression) {
-        SimpleIdentifier name18 = ((argument as NamedExpression)).name.label;
-        ParameterElement parameter = findNamedParameter(parameters13, name18.name);
+        SimpleIdentifier name2 = ((argument as NamedExpression)).name.label;
+        ParameterElement parameter = findNamedParameter(parameters2, name2.name);
         if (parameter != null) {
-          recordResolution(name18, parameter);
+          recordResolution(name2, parameter);
         }
       }
     }
   }
   /**
    * 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 bound4 = ((type as TypeVariableType)).element.bound;
-      if (bound4 == null) {
+      Type2 bound2 = ((type as TypeVariableType)).element.bound;
+      if (bound2 == null) {
         return _resolver.typeProvider.objectType;
       }
-      return bound4;
+      return bound2;
     }
     return type;
   }
 }
 class Identifier_8 extends Identifier {
-  String name10;
-  Identifier_8(this.name10) : super();
+  String name3;
+  Identifier_8(this.name3) : super();
   accept(ASTVisitor visitor) => null;
   sc.Token get beginToken => null;
   Element get element => null;
   sc.Token get endToken => null;
-  String get name => name10;
+  String get name => name3;
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code Library} represent the data about a single library during the
  * resolution of some (possibly different) library. They are not intended to be used except during
  * the resolution process.
  * @coverage dart.engine.resolver
  */
 class Library {
@@ skipping 267 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 definingCompilationUnit3 = library.definingCompilationUnit;
-    CompilationUnitElementImpl definingCompilationUnitElement = builder.buildCompilationUnit(librarySource2, definingCompilationUnit3);
-    NodeList<Directive> directives3 = definingCompilationUnit3.directives;
+    CompilationUnit definingCompilationUnit2 = library.definingCompilationUnit;
+    CompilationUnitElementImpl definingCompilationUnitElement = builder.buildCompilationUnit(librarySource2, definingCompilationUnit2);
+    NodeList<Directive> directives2 = definingCompilationUnit2.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 directives3) {
+    for (Directive directive in directives2) {
       if (directive is LibraryDirective) {
         if (libraryNameNode == null) {
           libraryNameNode = ((directive as LibraryDirective)).name;
           directivesToResolve.add(directive);
         }
       } else if (directive is PartDirective) {
         hasPartDirective = true;
         StringLiteral partUri = ((directive as PartDirective)).uri;
         Source partSource = library.getSource(partUri);
         if (partSource != null && partSource.exists()) {
@@ skipping 49 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 libraryName3 = ((directive as PartOfDirective)).libraryName;
-          if (libraryName3 != null) {
-            return libraryName3.name;
+          LibraryIdentifier libraryName2 = ((directive as PartOfDirective)).libraryName;
+          if (libraryName2 != null) {
+            return libraryName2.name;
           }
         }
       }
     } on AnalysisException catch (exception) {
     }
     return null;
   }
 }
 /**
  * Instances of the class {@code LibraryResolver} are used to resolve one or more mutually dependent
@@ skipping 244 matching lines @@
           if (exportedLibrary != null) {
             LibraryElement exportedLibraryElement = exportedLibrary.libraryElement;
             if (exportedLibraryElement != null) {
               exportElement.exportedLibrary = exportedLibraryElement;
             }
             directive.element = exportElement;
             exports.add(exportElement);
           }
         }
       }
-      Source librarySource3 = library.librarySource;
-      if (!library.explicitlyImportsCore && _coreLibrarySource != librarySource3) {
+      Source librarySource2 = library.librarySource;
+      if (!library.explicitlyImportsCore && _coreLibrarySource != librarySource2) {
         ImportElementImpl importElement = new ImportElementImpl();
         importElement.importedLibrary = _coreLibrary.libraryElement;
         importElement.synthetic = true;
         imports.add(importElement);
       }
-      LibraryElementImpl libraryElement3 = library.libraryElement;
-      libraryElement3.imports = new List.from(imports);
-      libraryElement3.exports = new List.from(exports);
+      LibraryElementImpl libraryElement2 = library.libraryElement;
+      libraryElement2.imports = new List.from(imports);
+      libraryElement2.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);
       LibraryElementImpl libraryElement = builder.buildLibrary(library);
@@ skipping 137 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> directives4 = node.directives;
-    for (Directive directive in directives4) {
+    NodeList<Directive> directives2 = node.directives;
+    for (Directive directive in directives2) {
       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
    * @return the lexical identifiers associated with the nodes in the list
@@ skipping 168 matching lines @@
   /**
    * Return the object keeping track of which elements have had their types overridden.
    * @return the object keeping track of which elements have had their types overridden
    */
   TypeOverrideManager get overrideManager => _overrideManager;
   Object visitAsExpression(AsExpression node) {
     super.visitAsExpression(node);
     if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
       VariableElement element = getOverridableElement(node.expression);
       if (element != null) {
-        Type2 type16 = node.type.type;
-        if (type16 != null) {
-          _overrideManager.setType(element, type16);
+        Type2 type2 = node.type.type;
+        if (type2 != null) {
+          _overrideManager.setType(element, type2);
         }
       }
     }
     return null;
   }
   Object visitAssertStatement(AssertStatement node) {
-    Expression condition3 = node.condition;
-    condition3.accept(this);
-    propagateTrueState(condition3);
+    Expression condition2 = node.condition;
+    condition2.accept(this);
+    propagateTrueState(condition2);
     return null;
   }
   Object visitBreakStatement(BreakStatement node) {
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement outerType = _enclosingClass;
     try {
@@ skipping 23 matching lines @@
       }
       for (CompilationUnitMember declaration in classes) {
         declaration.accept(this);
       }
     } finally {
       _overrideManager.exitScope();
     }
     return null;
   }
   Object visitConditionalExpression(ConditionalExpression node) {
-    Expression condition4 = node.condition;
-    condition4.accept(this);
+    Expression condition2 = node.condition;
+    condition2.accept(this);
     Expression thenExpression2 = node.thenExpression;
     if (thenExpression2 != null) {
       try {
         _overrideManager.enterScope();
-        propagateTrueState(condition4);
+        propagateTrueState(condition2);
         thenExpression2.accept(this);
       } finally {
         _overrideManager.exitScope();
       }
     }
     Expression elseExpression2 = node.elseExpression;
     if (elseExpression2 != null) {
       try {
         _overrideManager.enterScope();
-        propagateFalseState(condition4);
+        propagateFalseState(condition2);
         elseExpression2.accept(this);
       } finally {
         _overrideManager.exitScope();
       }
     }
     if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
       bool thenIsAbrupt = thenExpression2 != null && isAbruptTermination(thenExpression2);
       bool elseIsAbrupt = elseExpression2 != null && isAbruptTermination(elseExpression2);
       if (elseIsAbrupt && !thenIsAbrupt) {
-        propagateTrueState(condition4);
+        propagateTrueState(condition2);
       } else if (thenIsAbrupt && !elseIsAbrupt) {
-        propagateFalseState(condition4);
+        propagateFalseState(condition2);
       }
     }
     return null;
   }
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
       super.visitConstructorDeclaration(node);
     } finally {
@@ skipping 66 matching lines @@
       _overrideManager.enterScope();
       super.visitFunctionExpression(node);
     } finally {
       _overrideManager.exitScope();
       _enclosingFunction = outerFunction;
     }
     return null;
   }
   Object visitHideCombinator(HideCombinator node) => null;
   Object visitIfStatement(IfStatement node) {
-    Expression condition5 = node.condition;
-    condition5.accept(this);
+    Expression condition2 = node.condition;
+    condition2.accept(this);
     Statement thenStatement2 = node.thenStatement;
     if (thenStatement2 != null) {
       try {
         _overrideManager.enterScope();
-        propagateTrueState(condition5);
+        propagateTrueState(condition2);
         thenStatement2.accept(this);
       } finally {
         _overrideManager.exitScope();
       }
     }
     Statement elseStatement2 = node.elseStatement;
     if (elseStatement2 != null) {
       try {
         _overrideManager.enterScope();
-        propagateFalseState(condition5);
+        propagateFalseState(condition2);
         elseStatement2.accept(this);
       } finally {
         _overrideManager.exitScope();
       }
     }
     if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
       bool thenIsAbrupt = thenStatement2 != null && isAbruptTermination2(thenStatement2);
       bool elseIsAbrupt = elseStatement2 != null && isAbruptTermination2(elseStatement2);
       if (elseIsAbrupt && !thenIsAbrupt) {
-        propagateTrueState(condition5);
+        propagateTrueState(condition2);
       } else if (thenIsAbrupt && !elseIsAbrupt) {
-        propagateFalseState(condition5);
+        propagateFalseState(condition2);
       }
     }
     return null;
   }
   Object visitLabel(Label node) => null;
   Object visitLibraryIdentifier(LibraryIdentifier node) => null;
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
@@ skipping 85 matching lines @@
    * @return the element representing the function containing the current node
    */
   ExecutableElement get enclosingFunction => _enclosingFunction;
   /**
    * Return the element associated with the given expression whose type can be overridden, or{@code null} if there is no element whose type can be overridden.
    * @param expression the expression with which the element is associated
    * @return the element associated with the given expression
    */
   VariableElement getOverridableElement(Expression expression) {
     if (expression is SimpleIdentifier) {
-      Element element30 = ((expression as SimpleIdentifier)).element;
-      if (element30 is VariableElement) {
-        return element30 as VariableElement;
+      Element element2 = ((expression as SimpleIdentifier)).element;
+      if (element2 is VariableElement) {
+        return element2 as VariableElement;
       }
     }
     return null;
   }
   /**
    * 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 (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
       if (variableList.isConst() || variableList.isFinal()) {
         for (VariableDeclaration variable in variableList.variables) {
-          Element element31 = variable.element;
-          if (element31 != null) {
-            Type2 type = _overrideManager.getType(element31);
+          Element element2 = variable.element;
+          if (element2 != null) {
+            Type2 type = _overrideManager.getType(element2);
             if (type != null) {
-              overrides[element31] = type;
+              overrides[element2] = type;
             }
           }
         }
       }
     }
     return overrides;
   }
   /**
    * Return {@code true} if the given expression terminates abruptly (that is, if any expression
    * following the given expression will not be reached).
    * @param expression the expression being tested
    * @return {@code true} if the given expression terminates abruptly
    */
-  bool isAbruptTermination(Expression expression19) {
-    while (expression19 is ParenthesizedExpression) {
-      expression19 = ((expression19 as ParenthesizedExpression)).expression;
+  bool isAbruptTermination(Expression expression2) {
+    while (expression2 is ParenthesizedExpression) {
+      expression2 = ((expression2 as ParenthesizedExpression)).expression;
     }
-    return expression19 is ThrowExpression || expression19 is RethrowExpression;
+    return expression2 is ThrowExpression || expression2 is RethrowExpression;
   }
   /**
    * Return {@code true} if the given statement terminates abruptly (that is, if any statement
    * 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) {
       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 size6 = statements2.length;
-      if (size6 == 0) {
+      int size2 = statements2.length;
+      if (size2 == 0) {
         return false;
       }
-      return isAbruptTermination2(statements2[size6 - 1]);
+      return isAbruptTermination2(statements2[size2 - 1]);
     }
     return false;
   }
   /**
    * Propagate any type information that results from knowing that the given condition will have
    * evaluated to 'false'.
    * @param condition the condition that will have evaluated to 'false'
    */
   void propagateFalseState(Expression condition) {
     while (condition is ParenthesizedExpression) {
       condition = ((condition as ParenthesizedExpression)).expression;
     }
     if (condition is IsExpression) {
       IsExpression is2 = condition as IsExpression;
       if (is2.notOperator != null) {
         Element element = getOverridableElement(is2.expression);
         if (element != null) {
-          Type2 type17 = is2.type.type;
-          if (type17 != null) {
-            _overrideManager.setType(element, type17);
+          Type2 type2 = is2.type.type;
+          if (type2 != null) {
+            _overrideManager.setType(element, type2);
           }
         }
       }
     } else if (condition is BinaryExpression) {
       BinaryExpression binary = condition as BinaryExpression;
       if (identical(binary.operator.type, sc.TokenType.BAR_BAR)) {
         propagateFalseState(binary.leftOperand);
         propagateFalseState(binary.rightOperand);
       }
     }
   }
   /**
    * Propagate any type information that results from knowing that the given condition will have
    * evaluated to 'true'.
    * @param condition the condition that will have evaluated to 'true'
    */
   void propagateTrueState(Expression condition) {
     while (condition is ParenthesizedExpression) {
       condition = ((condition as ParenthesizedExpression)).expression;
     }
     if (condition is IsExpression) {
-      IsExpression is3 = condition as IsExpression;
-      if (is3.notOperator == null) {
-        Element element = getOverridableElement(is3.expression);
+      IsExpression is2 = condition as IsExpression;
+      if (is2.notOperator == null) {
+        Element element = getOverridableElement(is2.expression);
         if (element != null) {
-          Type2 type18 = is3.type.type;
-          if (type18 != null) {
-            _overrideManager.setType(element, type18);
+          Type2 type2 = is2.type.type;
+          if (type2 != null) {
+            _overrideManager.setType(element, type2);
           }
         }
       }
     } else if (condition is BinaryExpression) {
       BinaryExpression binary = condition as BinaryExpression;
       if (identical(binary.operator.type, sc.TokenType.AMPERSAND_AMPERSAND)) {
         propagateTrueState(binary.leftOperand);
         propagateTrueState(binary.rightOperand);
       }
     }
@@ skipping 47 matching lines @@
   /**
    * The scope used to resolve labels for {@code break} and {@code continue} statements, or{@code null} if no labels have been defined in the current context.
    */
   LabelScope _labelScope;
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    * @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 source8, TypeProvider typeProvider2) {
-    _jtd_constructor_267_impl(library, source8, typeProvider2);
+  ScopedVisitor.con1(Library library, Source source2, TypeProvider typeProvider2) {
+    _jtd_constructor_267_impl(library, source2, typeProvider2);
   }
-  _jtd_constructor_267_impl(Library library, Source source8, TypeProvider typeProvider2) {
+  _jtd_constructor_267_impl(Library library, Source source2, TypeProvider typeProvider2) {
     this._definingLibrary = library.libraryElement;
-    this._source = source8;
+    this._source = source2;
     LibraryScope libraryScope2 = library.libraryScope;
     this._errorListener = libraryScope2.errorListener;
     this._nameScope = libraryScope2;
     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
    * during resolution
    */
-  ScopedVisitor.con2(LibraryElement definingLibrary2, Source source9, TypeProvider typeProvider3, AnalysisErrorListener errorListener2) {
-    _jtd_constructor_268_impl(definingLibrary2, source9, typeProvider3, errorListener2);
+  ScopedVisitor.con2(LibraryElement definingLibrary2, Source source2, TypeProvider typeProvider2, AnalysisErrorListener errorListener2) {
+    _jtd_constructor_268_impl(definingLibrary2, source2, typeProvider2, errorListener2);
   }
-  _jtd_constructor_268_impl(LibraryElement definingLibrary2, Source source9, TypeProvider typeProvider3, AnalysisErrorListener errorListener2) {
+  _jtd_constructor_268_impl(LibraryElement definingLibrary2, Source source2, TypeProvider typeProvider2, AnalysisErrorListener errorListener2) {
     this._definingLibrary = definingLibrary2;
-    this._source = source9;
+    this._source = source2;
     this._errorListener = errorListener2;
     this._nameScope = new LibraryScope(definingLibrary2, errorListener2);
-    this._typeProvider = typeProvider3;
+    this._typeProvider = typeProvider2;
   }
   /**
    * Return the library element for the library containing the compilation unit being resolved.
    * @return the library element for the library containing the compilation unit being resolved
    */
   LibraryElement get definingLibrary => _definingLibrary;
   /**
    * Return the object used to access the types from the core library.
    * @return the object used to access the types from the core library
    */
@@ skipping 50 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 element32 = node.element;
-    if (element32 != null) {
-      _nameScope.define(element32);
+    VariableElement element2 = node.element;
+    if (element2 != null) {
+      _nameScope.define(element2);
     }
     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 element33 = node.element;
-      if (element33 != null) {
-        _nameScope.define(element33);
+      VariableElement element2 = node.element;
+      if (element2 != null) {
+        _nameScope.define(element2);
       }
     }
     super.visitVariableDeclaration(node);
     return null;
   }
   Object visitWhileStatement(WhileStatement node) {
     LabelScope outerScope = _labelScope;
     _labelScope = new LabelScope.con1(outerScope, false, false);
     try {
       super.visitWhileStatement(node);
@@ skipping 222 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 operator11 = node.operator.type;
-    if (operator11 != sc.TokenType.EQ) {
+    sc.TokenType operator2 = node.operator.type;
+    if (operator2 != sc.TokenType.EQ) {
       return recordReturnType(node, node.element);
     }
     Type2 rightType = getType2(node.rightHandSide);
     if (USE_TYPE_PROPAGATION) {
       VariableElement element = _resolver.getOverridableElement(node.leftHandSide);
       if (element != null) {
         override(element, getType(element), rightType);
       }
     }
     return recordType(node, rightType);
@@ skipping 29 matching lines @@
    * e<sub>2</sub></i> is equivalent to the method invocation
    * <i>super.op(e<sub>2</sub>)</i>.</blockquote>
    * <p>
    * The Dart Language Specification, 12.26: <blockquote>A multiplicative expression of the form
    * <i>e<sub>1</sub> op e<sub>2</sub></i> is equivalent to the method invocation
    * <i>e<sub>1</sub>.op(e<sub>2</sub>)</i>. A multiplicative expression of the form <i>super op
    * e<sub>2</sub></i> is equivalent to the method invocation
    * <i>super.op(e<sub>2</sub>)</i>.</blockquote>
    */
   Object visitBinaryExpression(BinaryExpression node) {
-    sc.TokenType operator12 = node.operator.type;
+    sc.TokenType operator2 = node.operator.type;
     while (true) {
-      if (operator12 == sc.TokenType.AMPERSAND_AMPERSAND || operator12 == sc.TokenType.BAR_BAR || operator12 == sc.TokenType.EQ_EQ || operator12 == sc.TokenType.BANG_EQ) {
+      if (operator2 == sc.TokenType.AMPERSAND_AMPERSAND || operator2 == sc.TokenType.BAR_BAR || operator2 == sc.TokenType.EQ_EQ || operator2 == sc.TokenType.BANG_EQ) {
         return recordType(node, _typeProvider.boolType);
-      } else if (operator12 == sc.TokenType.MINUS || operator12 == sc.TokenType.PERCENT || operator12 == sc.TokenType.PLUS || operator12 == sc.TokenType.STAR || operator12 == sc.TokenType.TILDE_SLASH) {
+      } else if (operator2 == sc.TokenType.MINUS || operator2 == sc.TokenType.PERCENT || operator2 == sc.TokenType.PLUS || operator2 == sc.TokenType.STAR || operator2 == sc.TokenType.TILDE_SLASH) {
         Type2 intType2 = _typeProvider.intType;
         if (identical(getType2(node.leftOperand), intType2) && identical(getType2(node.rightOperand), intType2)) {
           return recordType(node, intType2);
         }
-      } else if (operator12 == sc.TokenType.SLASH) {
+      } else if (operator2 == sc.TokenType.SLASH) {
         Type2 doubleType2 = _typeProvider.doubleType;
         if (identical(getType2(node.leftOperand), doubleType2) || identical(getType2(node.rightOperand), doubleType2)) {
           return recordType(node, doubleType2);
         }
       }
       break;
     }
     return recordReturnType(node, node.element);
   }
   /**
@@ skipping 100 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) {
     if (USE_TYPE_PROPAGATION) {
-      ConstructorElement element34 = node.element;
-      if (element34 != null && "Element" == element34.enclosingElement.name && "tag" == element34.name) {
-        LibraryElement library33 = element34.library;
-        if (isHtmlLibrary(library33)) {
-          Type2 returnType = getFirstArgumentAsType2(library33, node.argumentList, _HTML_ELEMENT_TO_CLASS_MAP);
+      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);
           if (returnType != null) {
             return recordType(node, returnType);
           }
         }
       }
     }
     return recordType(node, node.constructorName.type.type);
   }
   /**
    * The Dart Language Specification, 12.3: <blockquote>The static type of an integer literal is{@code int}.</blockquote>
    */
   Object visitIntegerLiteral(IntegerLiteral node) => recordType(node, _typeProvider.intType);
   /**
    * The Dart Language Specification, 12.31: <blockquote>It is a static warning if <i>T</i> does not
    * denote a type available in the current lexical scope.
    * <p>
    * The static type of an is-expression is {@code bool}.</blockquote>
    */
   Object visitIsExpression(IsExpression node) => recordType(node, _typeProvider.boolType);
   /**
    * 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) {
-    TypeArgumentList typeArguments8 = node.typeArguments;
-    if (typeArguments8 != null) {
-      NodeList<TypeName> arguments4 = typeArguments8.arguments;
-      if (arguments4 != null && arguments4.length == 1) {
-        TypeName argumentType = arguments4[0];
+    TypeArgumentList typeArguments2 = node.typeArguments;
+    if (typeArguments2 != null) {
+      NodeList<TypeName> arguments2 = typeArguments2.arguments;
+      if (arguments2 != null && arguments2.length == 1) {
+        TypeName argumentType = arguments2[0];
         return recordType(node, _typeProvider.listType.substitute5(<Type2> [getType4(argumentType)]));
       }
     }
     return recordType(node, _typeProvider.listType.substitute5(<Type2> [_dynamicType]));
   }
   /**
    * The Dart Language Specification, 12.7: <blockquote>The static type of a map literal of the form
    * <i><b>const</b> &lt;String, V&gt; {k<sub>1</sub>:e<sub>1</sub>, &hellip;,
    * k<sub>n</sub>:e<sub>n</sub>}</i> or the form <i>&lt;String, V&gt; {k<sub>1</sub>:e<sub>1</sub>,
    * &hellip;, k<sub>n</sub>:e<sub>n</sub>}</i> is {@code Map&lt;String, V&gt;}. The static type a
    * 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) {
-    TypeArgumentList typeArguments9 = node.typeArguments;
-    if (typeArguments9 != null) {
-      NodeList<TypeName> arguments5 = typeArguments9.arguments;
-      if (arguments5 != null && arguments5.length == 2) {
-        TypeName keyType = arguments5[0];
+    TypeArgumentList typeArguments2 = node.typeArguments;
+    if (typeArguments2 != null) {
+      NodeList<TypeName> arguments2 = typeArguments2.arguments;
+      if (arguments2 != null && arguments2.length == 2) {
+        TypeName keyType = arguments2[0];
         if (keyType != _typeProvider.stringType) {
         }
-        TypeName valueType = arguments5[1];
+        TypeName valueType = arguments2[1];
         return recordType(node, _typeProvider.mapType.substitute5(<Type2> [_typeProvider.stringType, getType4(valueType)]));
       }
     }
     return recordType(node, _typeProvider.mapType.substitute5(<Type2> [_typeProvider.stringType, _dynamicType]));
   }
   /**
    * The Dart Language Specification, 12.15.1: <blockquote>An ordinary method invocation <i>i</i>
    * has the form <i>o.m(a<sub>1</sub>, &hellip;, a<sub>n</sub>, x<sub>n+1</sub>: a<sub>n+1</sub>,
    * &hellip;, x<sub>n+k</sub>: a<sub>n+k</sub>)</i>.
    * <p>
@@ skipping 23 matching lines @@
    * It is a static type warning if <i>S</i> does not have an accessible instance member named m. If
    * <i>S.m</i> exists, it is a static warning if the type <i>F</i> of <i>S.m</i> may not be
    * assigned to a function type.
    * <p>
    * If <i>S.m</i> does not exist, or if <i>F</i> is not a function type, the static type of
    * <i>i</i> is dynamic. Otherwise the static type of <i>i</i> is the declared return type of
    * <i>F</i>.</blockquote>
    */
   Object visitMethodInvocation(MethodInvocation node) {
     if (USE_TYPE_PROPAGATION) {
-      String methodName3 = node.methodName.name;
-      if (methodName3 == "\$dom_createEvent") {
+      String methodName2 = node.methodName.name;
+      if (methodName2 == "\$dom_createEvent") {
         Expression target = node.realTarget;
         if (target != null) {
           Type2 targetType = getType2(target);
           if (targetType is InterfaceType && (targetType.name == "HtmlDocument" || targetType.name == "Document")) {
-            LibraryElement library34 = targetType.element.library;
-            if (isHtmlLibrary(library34)) {
-              Type2 returnType = getFirstArgumentAsType(library34, node.argumentList);
+            LibraryElement library2 = targetType.element.library;
+            if (isHtmlLibrary(library2)) {
+              Type2 returnType = getFirstArgumentAsType(library2, node.argumentList);
               if (returnType != null) {
                 return recordType(node, returnType);
               }
             }
           }
         }
-      } else if (methodName3 == "query") {
+      } else if (methodName2 == "query") {
         Expression target = node.realTarget;
         if (target == null) {
           Element methodElement = node.methodName.element;
           if (methodElement != null) {
-            LibraryElement library35 = methodElement.library;
-            if (isHtmlLibrary(library35)) {
-              Type2 returnType = getFirstArgumentAsQuery(library35, node.argumentList);
+            LibraryElement library3 = methodElement.library;
+            if (isHtmlLibrary(library3)) {
+              Type2 returnType = getFirstArgumentAsQuery(library3, node.argumentList);
               if (returnType != null) {
                 return recordType(node, returnType);
               }
             }
           }
         } else {
           Type2 targetType = getType2(target);
           if (targetType is InterfaceType && (targetType.name == "HtmlDocument" || targetType.name == "Document")) {
-            LibraryElement library36 = targetType.element.library;
-            if (isHtmlLibrary(library36)) {
-              Type2 returnType = getFirstArgumentAsQuery(library36, node.argumentList);
+            LibraryElement library4 = targetType.element.library;
+            if (isHtmlLibrary(library4)) {
+              Type2 returnType = getFirstArgumentAsQuery(library4, node.argumentList);
               if (returnType != null) {
                 return recordType(node, returnType);
               }
             }
           }
         }
-      } else if (methodName3 == "JS") {
+      } else if (methodName2 == "JS") {
         Type2 returnType = getFirstArgumentAsType(_typeProvider.objectType.element.library, node.argumentList);
         if (returnType != null) {
           return recordType(node, returnType);
         }
       }
     }
     return recordReturnType(node, node.methodName.element);
   }
   Object visitNamedExpression(NamedExpression node) => recordType(node, getType2(node.expression));
   /**
@@ skipping 27 matching lines @@
    * <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) => recordType(node, getType2(node.operand));
   /**
    * See {@link #visitSimpleIdentifier(SimpleIdentifier)}.
    */
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     SimpleIdentifier prefixedIdentifier = node.identifier;
-    Element element35 = prefixedIdentifier.element;
-    if (element35 == null) {
+    Element element2 = prefixedIdentifier.element;
+    if (element2 == null) {
       return recordType(node, _dynamicType);
     }
     if (USE_TYPE_PROPAGATION) {
-      Type2 type = _overrideManager.getType(element35);
+      Type2 type = _overrideManager.getType(element2);
       if (type != null) {
         return recordType(node, type);
       }
     }
     Type2 type;
-    if (element35 is ClassElement) {
+    if (element2 is ClassElement) {
       if (isNotTypeLiteral(node)) {
-        type = ((element35 as ClassElement)).type;
+        type = ((element2 as ClassElement)).type;
       } else {
         type = _typeProvider.typeType;
       }
-    } else if (element35 is FunctionTypeAliasElement) {
-      type = ((element35 as FunctionTypeAliasElement)).type;
-    } else if (element35 is MethodElement) {
-      type = ((element35 as MethodElement)).type;
-    } else if (element35 is PropertyAccessorElement) {
-      type = getType3((element35 as PropertyAccessorElement), node.prefix.staticType);
-    } else if (element35 is ExecutableElement) {
-      type = ((element35 as ExecutableElement)).type;
-    } else if (element35 is TypeVariableElement) {
-      type = ((element35 as TypeVariableElement)).type;
-    } else if (element35 is VariableElement) {
-      type = ((element35 as VariableElement)).type;
+    } else if (element2 is FunctionTypeAliasElement) {
+      type = ((element2 as FunctionTypeAliasElement)).type;
+    } else if (element2 is MethodElement) {
+      type = ((element2 as MethodElement)).type;
+    } else if (element2 is PropertyAccessorElement) {
+      type = getType3((element2 as PropertyAccessorElement), node.prefix.staticType);
+    } else if (element2 is ExecutableElement) {
+      type = ((element2 as ExecutableElement)).type;
+    } else if (element2 is TypeVariableElement) {
+      type = ((element2 as TypeVariableElement)).type;
+    } else if (element2 is VariableElement) {
+      type = ((element2 as VariableElement)).type;
     } else {
       type = _dynamicType;
     }
     recordType(prefixedIdentifier, type);
     return recordType(node, type);
   }
   /**
    * 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 operator13 = node.operator.type;
-    if (identical(operator13, sc.TokenType.BANG)) {
+    sc.TokenType operator2 = node.operator.type;
+    if (identical(operator2, sc.TokenType.BANG)) {
       return recordType(node, _typeProvider.boolType);
     }
     return recordReturnType(node, node.element);
   }
   /**
    * The Dart Language Specification, 12.13: <blockquote> Property extraction allows for a member of
    * an object to be concisely extracted from the object. If <i>o</i> is an object, and if <i>m</i>
    * is the name of a method member of <i>o</i>, then
    * <ul>
    * <li><i>o.m</i> is defined to be equivalent to: <i>(r<sub>1</sub>, &hellip;, r<sub>n</sub>,
@@ skipping 29 matching lines @@
    * 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 element36 = propertyName2.element;
+    Element element2 = propertyName2.element;
     if (USE_TYPE_PROPAGATION) {
-      Type2 type = _overrideManager.getType(element36);
+      Type2 type = _overrideManager.getType(element2);
       if (type != null) {
         return recordType(node, type);
       }
     }
-    if (element36 is MethodElement) {
-      FunctionType type19 = ((element36 as MethodElement)).type;
-      recordType(propertyName2, type19);
-      return recordType(node, type19);
-    } else if (element36 is PropertyAccessorElement) {
-      Type2 propertyType = getType3((element36 as PropertyAccessorElement), node.target != null ? node.target.staticType : null);
+    if (element2 is MethodElement) {
+      FunctionType type2 = ((element2 as MethodElement)).type;
+      recordType(propertyName2, type2);
+      return recordType(node, type2);
+    } else if (element2 is PropertyAccessorElement) {
+      Type2 propertyType = getType3((element2 as PropertyAccessorElement), node.target != null ? node.target.staticType : null);
       recordType(propertyName2, propertyType);
       return recordType(node, propertyType);
     } else {
     }
     recordType(propertyName2, _dynamicType);
     return recordType(node, _dynamicType);
   }
   /**
    * The Dart Language Specification, 12.9: <blockquote>The static type of a rethrow expression is
    * bottom.</blockquote>
@@ skipping 35 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 element37 = node.element;
-    if (element37 == null) {
+    Element element2 = node.element;
+    if (element2 == null) {
       return recordType(node, _dynamicType);
     }
     if (USE_TYPE_PROPAGATION) {
-      Type2 type = _overrideManager.getType(element37);
+      Type2 type = _overrideManager.getType(element2);
       if (type != null) {
         return recordType(node, type);
       }
     }
     Type2 type;
-    if (element37 is ClassElement) {
+    if (element2 is ClassElement) {
       if (isNotTypeLiteral(node)) {
-        type = ((element37 as ClassElement)).type;
+        type = ((element2 as ClassElement)).type;
       } else {
         type = _typeProvider.typeType;
       }
-    } else if (element37 is FunctionTypeAliasElement) {
-      type = ((element37 as FunctionTypeAliasElement)).type;
-    } else if (element37 is MethodElement) {
-      type = ((element37 as MethodElement)).type;
-    } else if (element37 is PropertyAccessorElement) {
-      type = getType3((element37 as PropertyAccessorElement), null);
-    } else if (element37 is ExecutableElement) {
-      type = ((element37 as ExecutableElement)).type;
-    } else if (element37 is TypeVariableElement) {
-      type = ((element37 as TypeVariableElement)).type;
-    } else if (element37 is VariableElement) {
-      type = ((element37 as VariableElement)).type;
-    } else if (element37 is PrefixElement) {
+    } else if (element2 is FunctionTypeAliasElement) {
+      type = ((element2 as FunctionTypeAliasElement)).type;
+    } else if (element2 is MethodElement) {
+      type = ((element2 as MethodElement)).type;
+    } else if (element2 is PropertyAccessorElement) {
+      type = getType3((element2 as PropertyAccessorElement), null);
+    } else if (element2 is ExecutableElement) {
+      type = ((element2 as ExecutableElement)).type;
+    } else if (element2 is TypeVariableElement) {
+      type = ((element2 as TypeVariableElement)).type;
+    } else if (element2 is VariableElement) {
+      type = ((element2 as VariableElement)).type;
+    } else if (element2 is PrefixElement) {
       return null;
     } else {
       type = _dynamicType;
     }
     return recordType(node, type);
   }
   /**
    * The Dart Language Specification, 12.5: <blockquote>The static type of a string literal is{@code String}.</blockquote>
    */
   Object visitSimpleStringLiteral(SimpleStringLiteral node) => recordType(node, _typeProvider.stringType);
@@ skipping 19 matching lines @@
       return recordType(node, _thisType);
     }
   }
   /**
    * The Dart Language Specification, 12.8: <blockquote>The static type of a throw expression is
    * bottom.</blockquote>
    */
   Object visitThrowExpression(ThrowExpression node) => recordType(node, _typeProvider.bottomType);
   Object visitVariableDeclaration(VariableDeclaration node) {
     if (USE_TYPE_PROPAGATION) {
-      Expression initializer6 = node.initializer;
-      if (initializer6 != null) {
-        Type2 rightType = getType2(initializer6);
-        VariableElement element38 = node.name.element as VariableElement;
-        if (element38 != null) {
-          override(element38, getType(element38), rightType);
+      Expression initializer2 = node.initializer;
+      if (initializer2 != null) {
+        Type2 rightType = getType2(initializer2);
+        VariableElement element2 = node.name.element as VariableElement;
+        if (element2 != null) {
+          override(element2, getType(element2), rightType);
         }
       }
     }
     return null;
   }
   /**
    * 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 computeReturnType(FunctionDeclaration node) {
-    TypeName returnType9 = node.returnType;
-    if (returnType9 == null) {
+    TypeName returnType2 = node.returnType;
+    if (returnType2 == null) {
       return computeReturnType2(node.functionExpression);
     }
-    return returnType9.type;
+    return returnType2.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 computeReturnType2(FunctionExpression node) {
-    FunctionBody body4 = node.body;
-    if (body4 is ExpressionFunctionBody) {
-      return getType2(((body4 as ExpressionFunctionBody)).expression);
+    FunctionBody body2 = node.body;
+    if (body2 is ExpressionFunctionBody) {
+      return getType2(((body2 as ExpressionFunctionBody)).expression);
     }
     return _dynamicType;
   }
   /**
    * If the given argument list contains at least one argument, and if the argument is a simple
    * string literal, then parse that argument as a query string and return the type specified by the
    * argument.
    * @param library the library in which the specified type would be defined
    * @param argumentList the list of arguments from which a type is to be extracted
    * @return the type specified by the first argument in the argument list
@@ skipping 17 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> arguments6 = argumentList.arguments;
-    if (arguments6.length > 0) {
-      Expression argument = arguments6[0];
+    NodeList<Expression> arguments2 = argumentList.arguments;
+    if (arguments2.length > 0) {
+      Expression argument = arguments2[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
    * given library, return the type specified by the argument.
@@ skipping 54 matching lines @@
   Type2 getType3(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 getter4 = accessor.variable.getter;
-      if (getter4 != null) {
-        functionType = getter4.type;
+      PropertyAccessorElement getter2 = accessor.variable.getter;
+      if (getter2 != null) {
+        functionType = getter2.type;
         if (functionType != null) {
           return functionType.returnType;
         }
       }
       return _dynamicType;
     }
-    Type2 returnType10 = functionType.returnType;
-    if (returnType10 is TypeVariableType && context is InterfaceType) {
+    Type2 returnType2 = functionType.returnType;
+    if (returnType2 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 (returnType10.name == varElt.name) {
+          if (returnType2.name == varElt.name) {
             return interfaceTypeContext.typeArguments[i];
           }
         }
       }
     }
-    return returnType10;
+    return returnType2;
   }
   /**
    * 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 getType4(TypeName typeName) {
-    Type2 type20 = typeName.type;
-    if (type20 == null) {
+    Type2 type2 = typeName.type;
+    if (type2 == null) {
       return _dynamicType;
     }
-    return type20;
+    return type2;
   }
   /**
    * 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 parent16 = node.parent;
-    return parent16 is TypeName || (parent16 is PrefixedIdentifier && (parent16.parent is TypeName || identical(((parent16 as PrefixedIdentifier)).prefix, node))) || (parent16 is PropertyAccess && identical(((parent16 as PropertyAccess)).target, node)) || (parent16 is MethodInvocation && identical(node, ((parent16 as MethodInvocation)).target));
+    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));
   }
   /**
    * If it is appropriate to do so, override the type of the given element. Use the static type and
    * inferred type of the element to determine whether or not it is appropriate.
    * @param element the element whose type might be overridden
    * @param staticType the static type of the element
    * @param inferredType the inferred type of the element
    */
   void override(VariableElement element, Type2 staticType, Type2 inferredType) {
     if (identical(inferredType, BottomTypeImpl.instance) || element is! VariableElement) {
@@ skipping 10 matching lines @@
     }
   }
   /**
    * 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 expression the node whose type is to be recorded
    * @param element the element representing the method invoked by the given node
    */
   Object recordArgumentType(IndexExpression expression, MethodElement element) {
     if (element != null) {
-      List<ParameterElement> parameters14 = element.parameters;
-      if (parameters14 != null && parameters14.length == 2) {
-        return recordType(expression, parameters14[1].type);
+      List<ParameterElement> parameters2 = element.parameters;
+      if (parameters2 != null && parameters2.length == 2) {
+        return recordType(expression, parameters2[1].type);
       }
     }
     return recordType(expression, _dynamicType);
   }
   /**
    * Record that the static type of the given node is the return type of the method or function
    * represented by the given element.
    * @param expression the node whose type is to be recorded
    * @param element the element representing the method or function invoked by the given node
    */
   Object recordReturnType(Expression expression, Element element) {
     if (element is PropertyAccessorElement) {
       FunctionType propertyType = ((element as PropertyAccessorElement)).type;
       if (propertyType != null) {
-        Type2 returnType11 = propertyType.returnType;
-        if (returnType11 is FunctionType) {
-          Type2 innerReturnType = ((returnType11 as FunctionType)).returnType;
+        Type2 returnType2 = propertyType.returnType;
+        if (returnType2 is FunctionType) {
+          Type2 innerReturnType = ((returnType2 as FunctionType)).returnType;
           if (innerReturnType != null) {
             return recordType(expression, innerReturnType);
           }
-        } else if (returnType11.isDartCoreFunction()) {
+        } else if (returnType2.isDartCoreFunction()) {
           return recordType(expression, _dynamicType);
         }
-        if (returnType11 != null) {
-          return recordType(expression, returnType11);
+        if (returnType2 != null) {
+          return recordType(expression, returnType2);
         }
       }
     } else if (element is ExecutableElement) {
-      FunctionType type21 = ((element as ExecutableElement)).type;
-      if (type21 != null) {
-        return recordType(expression, type21.returnType);
+      FunctionType type2 = ((element as ExecutableElement)).type;
+      if (type2 != null) {
+        return recordType(expression, type2.returnType);
       }
     } else if (element is VariableElement) {
       Type2 variableType = ((element as VariableElement)).type;
       if (variableType is FunctionType) {
         return recordType(expression, ((variableType as FunctionType)).returnType);
       }
     }
     return recordType(expression, _dynamicType);
   }
   /**
    * 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
    */
   Object recordType(Expression expression, Type2 type) {
     if (type == null) {
       expression.staticType = _dynamicType;
     } else {
       expression.staticType = type;
     }
     return null;
   }
   /**
    * 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
    * @param parameters the elements representing the parameters to the function
    */
-  void setTypeInformation(FunctionTypeImpl functionType, Type2 returnType14, FormalParameterList parameterList) {
+  void setTypeInformation(FunctionTypeImpl functionType, Type2 returnType2, FormalParameterList parameterList) {
     List<Type2> normalParameterTypes = new List<Type2>();
     List<Type2> optionalParameterTypes = new List<Type2>();
     LinkedHashMap<String, Type2> namedParameterTypes = new LinkedHashMap<String, Type2>();
     if (parameterList != null) {
       for (ParameterElement parameter in parameterList.elements) {
         while (true) {
           if (parameter.parameterKind == ParameterKind.REQUIRED) {
             normalParameterTypes.add(parameter.type);
           } else if (parameter.parameterKind == ParameterKind.POSITIONAL) {
             optionalParameterTypes.add(parameter.type);
           } else if (parameter.parameterKind == ParameterKind.NAMED) {
             namedParameterTypes[parameter.name] = parameter.type;
           }
           break;
         }
       }
     }
     functionType.normalParameterTypes = new List.from(normalParameterTypes);
     functionType.optionalParameterTypes = new List.from(optionalParameterTypes);
     functionType.namedParameterTypes = namedParameterTypes;
-    functionType.returnType = returnType14;
+    functionType.returnType = returnType2;
   }
   get thisType_J2DAccessor => _thisType;
   set thisType_J2DAccessor(__v) => _thisType = __v;
 }
 /**
  * Instances of the class {@code TypeOverrideManager} manage the ability to override the type of an
  * element within a given context.
  */
 class TypeOverrideManager {
   /**
@@ skipping 321 matching lines @@
     SimpleIdentifier exception = node.exceptionParameter;
     if (exception != null) {
       TypeName exceptionTypeName = node.exceptionType;
       Type2 exceptionType;
       if (exceptionTypeName == null) {
         exceptionType = typeProvider.objectType;
       } else {
         exceptionType = getType5(exceptionTypeName);
       }
       recordType(exception, exceptionType);
-      Element element39 = exception.element;
-      if (element39 is VariableElementImpl) {
-        ((element39 as VariableElementImpl)).type = exceptionType;
+      Element element2 = exception.element;
+      if (element2 is VariableElementImpl) {
+        ((element2 as VariableElementImpl)).type = exceptionType;
       } else {
       }
     }
     SimpleIdentifier stackTrace = node.stackTraceParameter;
     if (stackTrace != null) {
       recordType(stackTrace, typeProvider.stackTraceType);
     }
     return null;
   }
   Object visitClassDeclaration(ClassDeclaration node) {
     super.visitClassDeclaration(node);
     ClassElementImpl classElement = getClassElement(node.name);
     InterfaceType superclassType = null;
-    ExtendsClause extendsClause4 = node.extendsClause;
-    if (extendsClause4 != null) {
-      superclassType = resolveType(extendsClause4.superclass, CompileTimeErrorCode.EXTENDS_NON_CLASS);
+    ExtendsClause extendsClause2 = node.extendsClause;
+    if (extendsClause2 != null) {
+      superclassType = resolveType(extendsClause2.superclass, CompileTimeErrorCode.EXTENDS_NON_CLASS);
       if (superclassType != typeProvider.objectType) {
         classElement.validMixin = false;
       }
     }
     if (classElement != null) {
       if (superclassType == null) {
         InterfaceType objectType2 = typeProvider.objectType;
         if (classElement.type != objectType2) {
           superclassType = objectType2;
         }
@@ skipping 11 matching lines @@
       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 element40 = node.element as ExecutableElementImpl;
-    FunctionTypeImpl type = new FunctionTypeImpl.con1(element40);
-    setTypeInformation(type, null, element40.parameters);
-    type.returnType = ((element40.enclosingElement as ClassElement)).type;
-    element40.type = type;
+    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;
     return null;
   }
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     super.visitDeclaredIdentifier(node);
     Type2 declaredType;
     TypeName typeName = node.type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
       declaredType = getType5(typeName);
     }
-    LocalVariableElementImpl element41 = node.element as LocalVariableElementImpl;
-    element41.type = declaredType;
+    LocalVariableElementImpl element2 = node.element as LocalVariableElementImpl;
+    element2.type = declaredType;
     return null;
   }
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     super.visitDefaultFormalParameter(node);
     return null;
   }
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     super.visitFieldFormalParameter(node);
-    Element element42 = node.identifier.element;
-    if (element42 is ParameterElementImpl) {
-      ParameterElementImpl parameter = element42 as ParameterElementImpl;
+    Element element2 = node.identifier.element;
+    if (element2 is ParameterElementImpl) {
+      ParameterElementImpl parameter = element2 as ParameterElementImpl;
       Type2 type;
       TypeName typeName = node.type;
       if (typeName == null) {
         type = _dynamicType;
       } else {
         type = getType5(typeName);
       }
       parameter.type = type;
     } else {
     }
     return null;
   }
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     super.visitFunctionDeclaration(node);
-    ExecutableElementImpl element43 = node.element as ExecutableElementImpl;
-    FunctionTypeImpl type = new FunctionTypeImpl.con1(element43);
-    setTypeInformation(type, node.returnType, element43.parameters);
-    element43.type = type;
+    ExecutableElementImpl element2 = node.element as ExecutableElementImpl;
+    FunctionTypeImpl type = new FunctionTypeImpl.con1(element2);
+    setTypeInformation(type, node.returnType, element2.parameters);
+    element2.type = type;
     return null;
   }
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     super.visitFunctionTypeAlias(node);
-    FunctionTypeAliasElementImpl element44 = node.element as FunctionTypeAliasElementImpl;
-    FunctionTypeImpl type22 = element44.type as FunctionTypeImpl;
-    setTypeInformation(type22, node.returnType, element44.parameters);
+    FunctionTypeAliasElementImpl element2 = node.element as FunctionTypeAliasElementImpl;
+    FunctionTypeImpl type2 = element2.type as FunctionTypeImpl;
+    setTypeInformation(type2, node.returnType, element2.parameters);
     return null;
   }
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     super.visitFunctionTypedFormalParameter(node);
-    ParameterElementImpl element45 = node.identifier.element as ParameterElementImpl;
+    ParameterElementImpl element2 = node.identifier.element as ParameterElementImpl;
     FunctionTypeImpl type = new FunctionTypeImpl.con1((null as ExecutableElement));
     setTypeInformation(type, node.returnType, getElements(node.parameters));
-    element45.type = type;
+    element2.type = type;
     return null;
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
     super.visitMethodDeclaration(node);
-    ExecutableElementImpl element46 = node.element as ExecutableElementImpl;
-    FunctionTypeImpl type = new FunctionTypeImpl.con1(element46);
-    setTypeInformation(type, node.returnType, element46.parameters);
-    element46.type = type;
-    if (element46 is PropertyAccessorElement) {
-      PropertyAccessorElement accessor = element46 as PropertyAccessorElement;
-      PropertyInducingElementImpl variable6 = accessor.variable as PropertyInducingElementImpl;
+    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;
       if (accessor.isGetter()) {
-        variable6.type = type.returnType;
-      } else if (variable6.type == null) {
+        variable2.type = type.returnType;
+      } else if (variable2.type == null) {
         List<Type2> parameterTypes = type.normalParameterTypes;
         if (parameterTypes != null && parameterTypes.length > 0) {
-          variable6.type = parameterTypes[0];
+          variable2.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 = getType5(typeName);
     }
-    Element element47 = node.identifier.element;
-    if (element47 is ParameterElement) {
-      ((element47 as ParameterElementImpl)).type = declaredType;
+    Element element2 = node.identifier.element;
+    if (element2 is ParameterElement) {
+      ((element2 as ParameterElementImpl)).type = declaredType;
     } else {
     }
     return null;
   }
   Object visitTypeName(TypeName node) {
     super.visitTypeName(node);
     Identifier typeName = node.name;
     TypeArgumentList argumentList = node.typeArguments;
     Element element = nameScope.lookup(typeName, definingLibrary);
     if (element == null) {
       if (typeName.name == _dynamicType.name) {
         setElement(typeName, _dynamicType.element);
         if (argumentList != null) {
         }
         typeName.staticType = _dynamicType;
         node.type = _dynamicType;
         return null;
       }
       VoidTypeImpl voidType = VoidTypeImpl.instance;
       if (typeName.name == voidType.name) {
         if (argumentList != null) {
         }
         typeName.staticType = voidType;
         node.type = voidType;
         return null;
       }
-      ASTNode parent17 = node.parent;
-      if (typeName is PrefixedIdentifier && parent17 is ConstructorName && argumentList == null) {
-        ConstructorName name = parent17 as ConstructorName;
+      ASTNode parent2 = node.parent;
+      if (typeName is PrefixedIdentifier && parent2 is ConstructorName && argumentList == null) {
+        ConstructorName name = parent2 as ConstructorName;
         if (name.name == null) {
-          SimpleIdentifier prefix7 = ((typeName as PrefixedIdentifier)).prefix;
-          element = nameScope.lookup(prefix7, definingLibrary);
+          SimpleIdentifier prefix2 = ((typeName as PrefixedIdentifier)).prefix;
+          element = nameScope.lookup(prefix2, 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 = prefix7;
-            typeName = prefix7;
+            node.name = prefix2;
+            typeName = prefix2;
           }
         }
       }
     }
     if (element == null) {
       Identifier simpleIdentifier;
       if (typeName is SimpleIdentifier) {
         simpleIdentifier = typeName;
       } else {
         simpleIdentifier = ((typeName as PrefixedIdentifier)).prefix;
@@ skipping 22 matching lines @@
       if (type != null) {
         node.type = type;
       }
     } else {
       setElement(typeName, _dynamicType.element);
       typeName.staticType = _dynamicType;
       node.type = _dynamicType;
       return null;
     }
     if (argumentList != null) {
-      NodeList<TypeName> arguments7 = argumentList.arguments;
-      int argumentCount = arguments7.length;
+      NodeList<TypeName> arguments2 = argumentList.arguments;
+      int argumentCount = arguments2.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 = getType5(arguments7[i]);
+        Type2 argumentType = getType5(arguments2[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 = getType5(typeName);
     }
-    Element element48 = node.name.element;
-    if (element48 is VariableElement) {
-      ((element48 as VariableElementImpl)).type = declaredType;
-      if (element48 is PropertyInducingElement) {
-        PropertyInducingElement variableElement = element48 as PropertyInducingElement;
-        PropertyAccessorElementImpl getter5 = variableElement.getter as PropertyAccessorElementImpl;
-        FunctionTypeImpl getterType = new FunctionTypeImpl.con1(getter5);
+    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);
         getterType.returnType = declaredType;
-        getter5.type = getterType;
-        PropertyAccessorElementImpl setter4 = variableElement.setter as PropertyAccessorElementImpl;
-        if (setter4 != null) {
-          FunctionTypeImpl setterType = new FunctionTypeImpl.con1(setter4);
+        getter2.type = getterType;
+        PropertyAccessorElementImpl setter2 = variableElement.setter as PropertyAccessorElementImpl;
+        if (setter2 != null) {
+          FunctionTypeImpl setterType = new FunctionTypeImpl.con1(setter2);
           setterType.returnType = VoidTypeImpl.instance;
           setterType.normalParameterTypes = <Type2> [declaredType];
-          setter4.type = setterType;
+          setter2.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 element49 = identifier.element;
-    if (element49 is! ClassElementImpl) {
+    Element element2 = identifier.element;
+    if (element2 is! ClassElementImpl) {
       return null;
     }
-    return element49 as ClassElementImpl;
+    return element2 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 element50 = parameter.identifier.element as ParameterElement;
-      if (element50 != null) {
-        elements.add(element50);
+      ParameterElement element2 = parameter.identifier.element as ParameterElement;
+      if (element2 != null) {
+        elements.add(element2);
       }
     }
     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 parent18 = node.parent;
-    if (parent18 is ConstructorName) {
-      parent18 = parent18.parent;
-      if (parent18 is InstanceCreationExpression) {
-        if (((parent18 as InstanceCreationExpression)).isConst()) {
+    ASTNode parent2 = node.parent;
+    if (parent2 is ConstructorName) {
+      parent2 = parent2.parent;
+      if (parent2 is InstanceCreationExpression) {
+        if (((parent2 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;
   }
   /**
    * Given the multiple elements to which a single name could potentially be resolved, return the
@@ skipping 12 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 getType5(TypeName typeName) {
-    Type2 type23 = typeName.type;
-    if (type23 == null) {
+    Type2 type2 = typeName.type;
+    if (type2 == null) {
       return _dynamicType;
     }
-    return type23;
+    return type2;
   }
   /**
    * 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;
     } else if (type is FunctionType) {
@@ skipping 23 matching lines @@
    * @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);
       if (classElement != null) {
         classElement.mixins = mixinTypes2;
       }
     }
     if (implementsClause != null) {
-      NodeList<TypeName> interfaces3 = implementsClause.interfaces;
-      List<InterfaceType> interfaceTypes = resolveTypes(interfaces3, CompileTimeErrorCode.IMPLEMENTS_NON_CLASS);
-      List<TypeName> typeNames = new List.from(interfaces3);
+      NodeList<TypeName> interfaces2 = implementsClause.interfaces;
+      List<InterfaceType> interfaceTypes = resolveTypes(interfaces2, CompileTimeErrorCode.IMPLEMENTS_NON_CLASS);
+      List<TypeName> typeNames = new List.from(interfaces2);
       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 name19 = typeName.name.name;
-        if (name19 == dynamicKeyword) {
+        String name3 = typeName.name.name;
+        if (name3 == dynamicKeyword) {
           reportError(CompileTimeErrorCode.IMPLEMENTS_DYNAMIC, typeName, []);
         } else {
-          Element element51 = typeName.name.element;
-          if (element51 != null && element51 == classElement) {
-            reportError(CompileTimeErrorCode.IMPLEMENTS_SELF, typeName, [name19]);
+          Element element3 = typeName.name.element;
+          if (element3 != null && element3 == classElement) {
+            reportError(CompileTimeErrorCode.IMPLEMENTS_SELF, typeName, [name3]);
           }
         }
         if (!detectedRepeatOnIndex[i]) {
           for (int j = i + 1; j < typeNames.length; j++) {
-            Element element52 = typeName.name.element;
+            Element element4 = typeName.name.element;
             TypeName typeName2 = typeNames[j];
             Identifier identifier2 = typeName2.name;
             String name2 = identifier2.name;
             Element element2 = identifier2.element;
-            if (element52 != null && element52 == element2) {
+            if (element4 != null && element4 == 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 type24 = typeName.type;
-    if (type24 is InterfaceType) {
-      return type24 as InterfaceType;
+    Type2 type2 = typeName.type;
+    if (type2 is InterfaceType) {
+      return type2 as InterfaceType;
     }
-    Identifier name20 = typeName.name;
-    if (name20.name != sc.Keyword.DYNAMIC.syntax) {
-      reportError(nonTypeError, name20, [name20.name]);
+    Identifier name2 = typeName.name;
+    if (name2.name != sc.Keyword.DYNAMIC.syntax) {
+      reportError(nonTypeError, name2, [name2.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.
    */
   List<InterfaceType> resolveTypes(NodeList<TypeName> typeNames, ErrorCode nonTypeError) {
     List<InterfaceType> types = new List<InterfaceType>();
     for (TypeName typeName in typeNames) {
       InterfaceType type = resolveType(typeName, nonTypeError);
       if (type != null) {
         types.add(type);
       }
     }
     return new List.from(types);
   }
-  void setElement(Identifier typeName, Element element69) {
-    if (element69 != null) {
+  void setElement(Identifier typeName, Element element2) {
+    if (element2 != null) {
       if (typeName is SimpleIdentifier) {
-        ((typeName as SimpleIdentifier)).element = element69;
+        ((typeName as SimpleIdentifier)).element = element2;
       } else if (typeName is PrefixedIdentifier) {
         PrefixedIdentifier identifier = typeName as PrefixedIdentifier;
-        identifier.identifier.element = element69;
-        SimpleIdentifier prefix8 = identifier.prefix;
-        Element prefixElement = nameScope.lookup(prefix8, definingLibrary);
+        identifier.identifier.element = element2;
+        SimpleIdentifier prefix2 = identifier.prefix;
+        Element prefixElement = nameScope.lookup(prefix2, definingLibrary);
         if (prefixElement != null) {
-          prefix8.element = prefixElement;
+          prefix2.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
    * @param parameters the elements representing the parameters to the function
    */
-  void setTypeInformation(FunctionTypeImpl functionType, TypeName returnType15, List<ParameterElement> parameters) {
+  void setTypeInformation(FunctionTypeImpl functionType, TypeName returnType2, List<ParameterElement> parameters) {
     List<Type2> normalParameterTypes = new List<Type2>();
     List<Type2> optionalParameterTypes = new List<Type2>();
     LinkedHashMap<String, Type2> namedParameterTypes = new LinkedHashMap<String, Type2>();
     for (ParameterElement parameter in parameters) {
       while (true) {
         if (parameter.parameterKind == ParameterKind.REQUIRED) {
           normalParameterTypes.add(parameter.type);
         } else if (parameter.parameterKind == ParameterKind.POSITIONAL) {
           optionalParameterTypes.add(parameter.type);
         } else if (parameter.parameterKind == ParameterKind.NAMED) {
           namedParameterTypes[parameter.name] = parameter.type;
         }
         break;
       }
     }
     if (!normalParameterTypes.isEmpty) {
       functionType.normalParameterTypes = new List.from(normalParameterTypes);
     }
     if (!optionalParameterTypes.isEmpty) {
       functionType.optionalParameterTypes = new List.from(optionalParameterTypes);
     }
     if (!namedParameterTypes.isEmpty) {
       functionType.namedParameterTypes = namedParameterTypes;
     }
-    if (returnType15 == null) {
+    if (returnType2 == null) {
       functionType.returnType = _dynamicType;
     } else {
-      functionType.returnType = returnType15.type;
+      functionType.returnType = returnType2.type;
     }
   }
 }
 /**
  * Instances of the class {@code ClassScope} implement the scope defined by a class.
  * @coverage dart.engine.resolver
  */
 class ClassScope extends EnclosedScope {
   /**
    * Initialize a newly created scope enclosed within another scope.
@@ skipping 72 matching lines @@
   FunctionScope(Scope enclosingScope, ExecutableElement functionElement) : super(new EnclosedScope(enclosingScope)) {
     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 name21 = functionElement.name;
-      if (name21 != null && !name21.isEmpty) {
+      String name2 = functionElement.name;
+      if (name2 != null && !name2.isEmpty) {
         parameterScope.define(functionElement);
       }
     }
     for (ParameterElement parameter in functionElement.parameters) {
       if (!parameter.isInitializingFormal()) {
         parameterScope.define(parameter);
       }
     }
   }
 }
@@ skipping 58 matching lines @@
   }
   _jtd_constructor_279_impl(LabelScope outerScope, bool onSwitchStatement, bool onSwitchMember) {
     _jtd_constructor_280_impl(outerScope, EMPTY_LABEL, new LabelElementImpl(_EMPTY_LABEL_IDENTIFIER, onSwitchStatement, onSwitchMember));
   }
   /**
    * Initialize a newly created scope to represent the given label.
    * @param outerScope the label scope enclosing the new label scope
    * @param label the label defined in this scope
    * @param element the element to which the label resolves
    */
-  LabelScope.con2(LabelScope outerScope2, String label4, LabelElement element21) {
-    _jtd_constructor_280_impl(outerScope2, label4, element21);
+  LabelScope.con2(LabelScope outerScope2, String label2, LabelElement element2) {
+    _jtd_constructor_280_impl(outerScope2, label2, element2);
   }
-  _jtd_constructor_280_impl(LabelScope outerScope2, String label4, LabelElement element21) {
+  _jtd_constructor_280_impl(LabelScope outerScope2, String label2, LabelElement element2) {
     this._outerScope = outerScope2;
-    this._label = label4;
-    this._element = element21;
+    this._label = label2;
+    this._element = element2;
   }
   /**
    * Return the label element corresponding to the given label, or {@code null} if the given label
    * is not defined in this scope.
    * @param targetLabel the label being looked up
    * @return the label element corresponding to the given label
    */
   LabelElement lookup(SimpleIdentifier targetLabel) => lookup2(targetLabel.name);
   /**
    * Return the label element corresponding to the given label, or {@code null} if the given label
@@ skipping 184 matching lines @@
    * @param library the library whose export namespace is to be created
    * @return the export namespace that was created
    */
   Namespace createExportNamespace(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 importedLibrary4 = element.importedLibrary;
-    if (importedLibrary4 == null) {
+    LibraryElement importedLibrary2 = element.importedLibrary;
+    if (importedLibrary2 == null) {
       return Namespace.EMPTY;
     }
-    Map<String, Element> definedNames = createExportMapping(importedLibrary4, new Set<LibraryElement>());
+    Map<String, Element> definedNames = createExportMapping(importedLibrary2, 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
    */
   Namespace createPublicNamespace(LibraryElement library) {
@@ skipping 23 matching lines @@
     if (namespace != null) {
       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 name22 = element.name;
-    if (name22 != null && !Scope.isPrivateName(name22)) {
-      definedNames[name22] = element;
+    String name2 = element.name;
+    if (name2 != null && !Scope.isPrivateName(name2)) {
+      definedNames[name2] = 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
    */
   void addPublicNames(Map<String, Element> definedNames, CompilationUnitElement compilationUnit) {
@@ skipping 53 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 exportedLibrary3 = element.exportedLibrary;
-        if (exportedLibrary3 != null && !visitedElements.contains(exportedLibrary3)) {
-          Map<String, Element> exportedNames = createExportMapping(exportedLibrary3, visitedElements);
+        LibraryElement exportedLibrary2 = element.exportedLibrary;
+        if (exportedLibrary2 != null && !visitedElements.contains(exportedLibrary2)) {
+          Map<String, Element> exportedNames = createExportMapping(exportedLibrary2, visitedElements);
           exportedNames = apply(exportedNames, element.combinators);
           addAll(definedNames, exportedNames);
         }
       }
       addAll2(definedNames, ((library.context as InternalAnalysisContext)).getPublicNamespace(library));
       return definedNames;
     } finally {
       visitedElements.remove(library);
     }
   }
@@ skipping 99 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 source15 = duplicate.source;
-    if (source15 == null) {
-      source15 = source;
+    Source source2 = duplicate.source;
+    if (source2 == null) {
+      source2 = source;
     }
-    return new AnalysisError.con2(source15, duplicate.nameOffset, duplicate.name.length, CompileTimeErrorCode.DUPLICATE_DEFINITION, [existing.name]);
+    return new AnalysisError.con2(source2, duplicate.nameOffset, duplicate.name.length, CompileTimeErrorCode.DUPLICATE_DEFINITION, [existing.name]);
   }
   /**
    * 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
    * scope should be associated.
    * @return the source object with which errors should be associated
@@ skipping 68 matching lines @@
         validate(element, CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT);
       }
     }
     return null;
   }
   Object visitMapLiteral(MapLiteral node) {
     super.visitMapLiteral(node);
     bool isConst = node.modifier != null;
     Set<String> keys = new Set<String>();
     for (MapLiteralEntry entry in node.entries) {
-      StringLiteral key4 = entry.key;
-      EvaluationResultImpl result = validate(key4, CompileTimeErrorCode.NON_CONSTANT_MAP_KEY);
+      StringLiteral key2 = entry.key;
+      EvaluationResultImpl result = validate(key2, CompileTimeErrorCode.NON_CONSTANT_MAP_KEY);
       if (result is ValidResult && ((result as ValidResult)).value is String) {
-        String value11 = ((result as ValidResult)).value as String;
-        if (keys.contains(value11)) {
-          _errorReporter.reportError(StaticWarningCode.EQUAL_KEYS_IN_MAP, key4, []);
+        String value2 = ((result as ValidResult)).value as String;
+        if (keys.contains(value2)) {
+          _errorReporter.reportError(StaticWarningCode.EQUAL_KEYS_IN_MAP, key2, []);
         } else {
-          javaSetAdd(keys, value11);
+          javaSetAdd(keys, value2);
         }
       }
       if (isConst) {
         validate(entry.value, CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE);
       }
     }
     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 initializer7 = node.initializer;
-    if (initializer7 != null && node.isConst()) {
-      VariableElementImpl element58 = node.element as VariableElementImpl;
-      EvaluationResultImpl result = element58.evaluationResult;
+    Expression initializer2 = node.initializer;
+    if (initializer2 != null && node.isConst()) {
+      VariableElementImpl element2 = node.element as VariableElementImpl;
+      EvaluationResultImpl result = element2.evaluationResult;
       if (result == null) {
-        result = validate(initializer7, CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
-        element58.evaluationResult = result;
+        result = validate(initializer2, CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
+        element2.evaluationResult = result;
       } else if (result is ErrorResult) {
         reportErrors(result, CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
       }
     }
     return null;
   }
   /**
    * If the given result represents one or more errors, report those errors. Except for special
    * cases, use the given error code rather than the one reported in the error.
    * @param result the result containing any errors that need to be reported
@@ skipping 16 matching lines @@
   EvaluationResultImpl validate(Expression expression, ErrorCode errorCode) {
     EvaluationResultImpl result = expression.accept(new ConstantVisitor());
     reportErrors(result, errorCode);
     return result;
   }
   /**
    * 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 parameters17) {
-    if (parameters17 == null) {
+  void validateDefaultValues(FormalParameterList parameters2) {
+    if (parameters2 == null) {
       return;
     }
-    for (FormalParameter parameter in parameters17.parameters) {
+    for (FormalParameter parameter in parameters2.parameters) {
       if (parameter is DefaultFormalParameter) {
         DefaultFormalParameter defaultParameter = parameter as DefaultFormalParameter;
-        Expression defaultValue3 = defaultParameter.defaultValue;
-        if (defaultValue3 != null) {
-          EvaluationResultImpl result = validate(defaultValue3, CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE);
+        Expression defaultValue2 = defaultParameter.defaultValue;
+        if (defaultValue2 != null) {
+          EvaluationResultImpl result = validate(defaultValue2, CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE);
           if (defaultParameter.isConst()) {
-            VariableElementImpl element59 = parameter.element as VariableElementImpl;
-            element59.evaluationResult = result;
+            VariableElementImpl element2 = parameter.element as VariableElementImpl;
+            element2.evaluationResult = result;
           }
         }
       }
     }
   }
 }
 /**
  * Instances of the class {@code ErrorVerifier} traverse an AST structure looking for additional
  * errors and warnings not covered by the parser and resolver.
  * @coverage dart.engine.resolver
@@ skipping 160 matching lines @@
   }
   Object visitIfStatement(IfStatement node) {
     checkForNonBoolCondition(node.condition);
     return super.visitIfStatement(node);
   }
   Object visitImplementsClause(ImplementsClause node) {
     checkForImplementsDisallowedClass(node);
     return super.visitImplementsClause(node);
   }
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
-    ConstructorName constructorName4 = node.constructorName;
-    TypeName typeName = constructorName4.type;
-    Type2 type25 = typeName.type;
-    if (type25 is InterfaceType) {
-      InterfaceType interfaceType = type25 as InterfaceType;
+    ConstructorName constructorName2 = node.constructorName;
+    TypeName typeName = constructorName2.type;
+    Type2 type2 = typeName.type;
+    if (type2 is InterfaceType) {
+      InterfaceType interfaceType = type2 as InterfaceType;
       checkForConstWithNonConst(node);
       checkForConstOrNewWithAbstractClass(node, typeName, interfaceType);
-      checkForTypeArgumentNotMatchingBounds(node, constructorName4.element, typeName);
+      checkForTypeArgumentNotMatchingBounds(node, constructorName2.element, typeName);
     }
     return super.visitInstanceCreationExpression(node);
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement previousFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
       return super.visitMethodDeclaration(node);
     } finally {
       _enclosingFunction = previousFunction;
@@ skipping 80 matching lines @@
             _errorReporter.reportError(CompileTimeErrorCode.FINAL_INITIALIZED_MULTIPLE_TIMES, formalParameter.identifier, [fieldElement.name]);
             foundError = true;
           }
         }
       }
     }
     NodeList<ConstructorInitializer> initializers2 = node.initializers;
     for (ConstructorInitializer constructorInitializer in initializers2) {
       if (constructorInitializer is ConstructorFieldInitializer) {
         ConstructorFieldInitializer constructorFieldInitializer = constructorInitializer as ConstructorFieldInitializer;
-        SimpleIdentifier fieldName3 = constructorFieldInitializer.fieldName;
-        Element element60 = fieldName3.element;
-        if (element60 is FieldElement) {
-          FieldElement fieldElement = element60 as FieldElement;
+        SimpleIdentifier fieldName2 = constructorFieldInitializer.fieldName;
+        Element element2 = fieldName2.element;
+        if (element2 is FieldElement) {
+          FieldElement fieldElement = element2 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.reportError(CompileTimeErrorCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION, fieldName3, []);
+              _errorReporter.reportError(CompileTimeErrorCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION, fieldName2, []);
               foundError = true;
             }
           } else if (identical(state, INIT_STATE.INIT_IN_FIELD_FORMAL)) {
-            _errorReporter.reportError(CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER, fieldName3, []);
+            _errorReporter.reportError(CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER, fieldName2, []);
             foundError = true;
           } else if (identical(state, INIT_STATE.INIT_IN_INITIALIZERS)) {
-            _errorReporter.reportError(CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS, fieldName3, [fieldElement.name]);
+            _errorReporter.reportError(CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS, fieldName2, [fieldElement.name]);
             foundError = true;
           }
         }
       }
     }
     return foundError;
   }
   /**
    * This verifies that the passed argument definition test identifier is a parameter.
    * @param node the {@link ArgumentDefinitionTest} to evaluate
    * @return 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 identifier15 = node.identifier;
-    Element element61 = identifier15.element;
-    if (element61 != null && element61 is! ParameterElement) {
-      _errorReporter.reportError(CompileTimeErrorCode.ARGUMENT_DEFINITION_TEST_NON_PARAMETER, identifier15, [identifier15.name]);
+    SimpleIdentifier identifier2 = node.identifier;
+    Element element2 = identifier2.element;
+    if (element2 != null && element2 is! ParameterElement) {
+      _errorReporter.reportError(CompileTimeErrorCode.ARGUMENT_DEFINITION_TEST_NON_PARAMETER, identifier2, [identifier2.name]);
       return true;
     }
     return false;
   }
   /**
    * This verifies that the passed identifier is not a keyword, and generates the passed error code
    * 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 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 token18 = identifier.token;
-    if (identical(token18.type, sc.TokenType.KEYWORD)) {
+    sc.Token token2 = identifier.token;
+    if (identical(token2.type, sc.TokenType.KEYWORD)) {
       _errorReporter.reportError(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 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 token19 = simpleIdentifier.token;
-        if (identical(token19.type, sc.TokenType.KEYWORD)) {
-          if (((token19 as sc.KeywordToken)).keyword != sc.Keyword.DYNAMIC) {
+        sc.Token token2 = simpleIdentifier.token;
+        if (identical(token2.type, sc.TokenType.KEYWORD)) {
+          if (((token2 as sc.KeywordToken)).keyword != sc.Keyword.DYNAMIC) {
             _errorReporter.reportError(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE, identifier, [identifier.name]);
             return true;
           }
         }
       }
     }
     return false;
   }
   /**
    * 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 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 expression16 = node.expression;
-    Type2 type = expression16.staticType;
+    Expression expression2 = node.expression;
+    Type2 type = expression2.staticType;
     if (type != null && type != _typeProvider.intType && type != _typeProvider.stringType) {
-      Element element62 = type.element;
-      if (element62 is ClassElement) {
-        ClassElement classElement = element62 as ClassElement;
+      Element element2 = type.element;
+      if (element2 is ClassElement) {
+        ClassElement classElement = element2 as ClassElement;
         MethodElement method = classElement.lookUpMethod("==", _currentLibrary);
         if (method != null && method.enclosingElement.type != _typeProvider.objectType) {
-          _errorReporter.reportError(CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS, expression16, [element62.name]);
+          _errorReporter.reportError(CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS, expression2, [element2.name]);
           return true;
         }
       }
     }
     return false;
   }
   bool checkForConflictingConstructorNameAndMember(ConstructorDeclaration node) {
     ConstructorElement constructorElement = node.element;
     SimpleIdentifier constructorName = node.name;
     if (constructorName != null && constructorElement != null && !constructorName.isSynthetic()) {
-      String name24 = constructorName.name;
+      String name2 = constructorName.name;
       ClassElement classElement = constructorElement.enclosingElement;
-      List<FieldElement> fields3 = classElement.fields;
-      for (FieldElement field in fields3) {
-        if (field.name == name24) {
-          _errorReporter.reportError(CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD, node, [name24]);
+      List<FieldElement> fields2 = classElement.fields;
+      for (FieldElement field in fields2) {
+        if (field.name == name2) {
+          _errorReporter.reportError(CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD, node, [name2]);
           return true;
         }
       }
-      List<MethodElement> methods3 = classElement.methods;
-      for (MethodElement method in methods3) {
-        if (method.name == name24) {
-          _errorReporter.reportError(CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD, node, [name24]);
+      List<MethodElement> methods2 = classElement.methods;
+      for (MethodElement method in methods2) {
+        if (method.name == name2) {
+          _errorReporter.reportError(CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD, node, [name2]);
           return true;
         }
       }
     }
     return false;
   }
   /**
    * This verifies that the passed constructor declaration is not 'const' if it has a non-final
    * instance variable.
    * @param node the instance creation expression to evaluate
@@ skipping 49 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 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 element63 = node.element;
-      if (element63 != null && !element63.isFactory()) {
+      ConstructorElement element2 = node.element;
+      if (element2 != null && !element2.isFactory()) {
         if (identical(((node.keyword as sc.KeywordToken)).keyword, sc.Keyword.CONST)) {
           _errorReporter.reportError(StaticWarningCode.CONST_WITH_ABSTRACT_CLASS, typeName, []);
         } else {
           _errorReporter.reportError(StaticWarningCode.NEW_WITH_ABSTRACT_CLASS, typeName, []);
         }
         return true;
       }
     }
     return false;
   }
@@ skipping 14 matching lines @@
   }
   /**
    * This verifies that there are no default parameters in the passed function type alias.
    * @param node the function type alias to evaluate
    * @return 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> parameters15 = formalParameterList.parameters;
-    for (FormalParameter formalParameter in parameters15) {
+    NodeList<FormalParameter> parameters2 = formalParameterList.parameters;
+    for (FormalParameter formalParameter in parameters2) {
       if (formalParameter is DefaultFormalParameter) {
         DefaultFormalParameter defaultFormalParameter = formalParameter as DefaultFormalParameter;
         if (defaultFormalParameter.defaultValue != null) {
           _errorReporter.reportError(CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS, node, []);
           result = true;
         }
       }
     }
     return result;
   }
@@ skipping 37 matching lines @@
     }
     return false;
   }
   /**
    * This verifies that the passed field formal parameter is in a constructor declaration.
    * @param node the field formal parameter to test
    * @return return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR
    */
   bool checkForFieldInitializerOutsideConstructor(FieldFormalParameter node) {
-    ASTNode parent19 = node.parent;
-    if (parent19 != null) {
-      ASTNode grandparent = parent19.parent;
+    ASTNode parent2 = node.parent;
+    if (parent2 != null) {
+      ASTNode grandparent = parent2.parent;
       if (grandparent != null && grandparent is! ConstructorDeclaration && grandparent.parent is! ConstructorDeclaration) {
         _errorReporter.reportError(CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR, node, []);
         return true;
       }
     }
     return false;
   }
   /**
    * This verifies that final fields that are declared, without any constructors in the enclosing
    * class, are initialized. Cases in which there is at least one constructor are handled at the end
@@ skipping 21 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> variables3 = node.variables;
-      for (VariableDeclaration variable in variables3) {
+      NodeList<VariableDeclaration> variables2 = node.variables;
+      for (VariableDeclaration variable in variables2) {
         if (variable.initializer == null) {
           _errorReporter.reportError(CompileTimeErrorCode.FINAL_NOT_INITIALIZED, variable, [variable.name.name]);
           foundError = true;
         }
       }
     }
     return foundError;
   }
   /**
    * This verifies that the passed implements clause does not implement classes such as 'num' or
@@ skipping 15 matching lines @@
    * @return 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 expression17 = switchCase.expression;
+        Expression expression2 = switchCase.expression;
         if (firstType == null) {
-          firstType = expression17.staticType;
+          firstType = expression2.staticType;
         } else {
-          Type2 nType = expression17.staticType;
+          Type2 nType = expression2.staticType;
           if (firstType != nType) {
-            _errorReporter.reportError(CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES, expression17, [expression17.toSource(), firstType.name]);
+            _errorReporter.reportError(CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES, expression2, [expression2.toSource(), firstType.name]);
             foundError = true;
           }
         }
       }
     }
     return foundError;
   }
   /**
    * This verifies that the passed assignment expression represents a valid assignment.
    * @param node the assignment expression to evaluate
@@ skipping 135 matching lines @@
     return type == null ? _dynamicType : type;
   }
   /**
    * 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 element64 = ((expression as Identifier)).element;
-      if (element64 is VariableElement) {
-        return element64 as VariableElement;
+      Element element2 = ((expression as Identifier)).element;
+      if (element2 is VariableElement) {
+        return element2 as VariableElement;
       }
     }
     return null;
   }
 }
 /**
  * This enum holds one of four states of a field initialization state through a constructor
  * signature, not initialized, initialized in the field declaration, initialized in the field
  * formal, and finally, initialized in the initializers list.
  */
@@ skipping 44 matching lines @@
     this._type = type;
     this._message = message;
   }
   ErrorSeverity get errorSeverity => _type.severity;
   String get message => _message;
   ErrorType get type => _type;
   bool needsRecompilation() => true;
   int compareTo(ResolverErrorCode other) => __ordinal - other.__ordinal;
   String toString() => __name;
 }