Rename parameters in error_verifier

pkg/analyzer/lib/src/generated/error_verifier.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library engine.resolver.error_verifier;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/static_type_analyzer.dart';
@@ skipping 1106 matching lines @@
 
   /**
    * Verify that the given [constructor] declaration does not violate any of the
    * error codes relating to the initialization of fields in the enclosing
    * class.
    *
    * See [_initialFieldElementsMap],
    * [StaticWarningCode.FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR], and
    * [CompileTimeErrorCode.FINAL_INITIALIZED_MULTIPLE_TIMES].
    */
-  bool _checkForAllFinalInitializedErrorCodes(ConstructorDeclaration node) {
-    if (node.factoryKeyword != null ||
-        node.redirectedConstructor != null ||
-        node.externalKeyword != null) {
+  bool _checkForAllFinalInitializedErrorCodes(
+      ConstructorDeclaration constructor) {
+    if (constructor.factoryKeyword != null ||
+        constructor.redirectedConstructor != null ||
+        constructor.externalKeyword != null) {
       return false;
     }
     // Ignore if native class.
     if (_isInNativeClass) {
       return false;
     }
     bool foundError = false;
     HashMap<FieldElement, INIT_STATE> fieldElementsMap =
         new HashMap<FieldElement, INIT_STATE>.from(_initialFieldElementsMap);
     // Visit all of the field formal parameters
-    NodeList<FormalParameter> formalParameters = node.parameters.parameters;
+    NodeList<FormalParameter> formalParameters =
+        constructor.parameters.parameters;
     for (FormalParameter formalParameter in formalParameters) {
       FormalParameter parameter = formalParameter;
       if (parameter is DefaultFormalParameter) {
         parameter = (parameter as DefaultFormalParameter).parameter;
       }
       if (parameter is FieldFormalParameter) {
         FieldElement fieldElement =
             (parameter.element as FieldFormalParameterElementImpl).field;
         INIT_STATE state = fieldElementsMap[fieldElement];
         if (state == INIT_STATE.NOT_INIT) {
           fieldElementsMap[fieldElement] = INIT_STATE.INIT_IN_FIELD_FORMAL;
         } else if (state == INIT_STATE.INIT_IN_DECLARATION) {
           if (fieldElement.isFinal || fieldElement.isConst) {
             _errorReporter.reportErrorForNode(
                 StaticWarningCode.FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR,
                 formalParameter.identifier, [fieldElement.displayName]);
             foundError = true;
           }
         } else if (state == INIT_STATE.INIT_IN_FIELD_FORMAL) {
           if (fieldElement.isFinal || fieldElement.isConst) {
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.FINAL_INITIALIZED_MULTIPLE_TIMES,
                 formalParameter.identifier, [fieldElement.displayName]);
             foundError = true;
           }
         }
       }
     }
     // Visit all of the initializers
-    NodeList<ConstructorInitializer> initializers = node.initializers;
+    NodeList<ConstructorInitializer> initializers = constructor.initializers;
     for (ConstructorInitializer constructorInitializer in initializers) {
       if (constructorInitializer is RedirectingConstructorInvocation) {
         return false;
       }
       if (constructorInitializer is ConstructorFieldInitializer) {
         ConstructorFieldInitializer constructorFieldInitializer =
             constructorInitializer;
         SimpleIdentifier fieldName = constructorFieldInitializer.fieldName;
         Element element = fieldName.staticElement;
         if (element is FieldElement) {
@@ skipping 30 matching lines @@
           notInitFinalFields.add(fieldElement);
         }
       }
     });
     // Visit all of the states in the map to ensure that none were never
     // initialized.
     fieldElementsMap.forEach((FieldElement fieldElement, INIT_STATE state) {
       if (state == INIT_STATE.NOT_INIT) {
         if (fieldElement.isConst) {
           _errorReporter.reportErrorForNode(
-              CompileTimeErrorCode.CONST_NOT_INITIALIZED, node.returnType,
-              [fieldElement.name]);
+              CompileTimeErrorCode.CONST_NOT_INITIALIZED,
+              constructor.returnType, [fieldElement.name]);
           foundError = true;
         }
       }
     });
     if (notInitFinalFields.isNotEmpty) {
       foundError = true;
       AnalysisErrorWithProperties analysisError;
       if (notInitFinalFields.length == 1) {
         analysisError = _errorReporter.newErrorWithProperties(
             StaticWarningCode.FINAL_NOT_INITIALIZED_CONSTRUCTOR_1,
-            node.returnType, [notInitFinalFields[0].name]);
+            constructor.returnType, [notInitFinalFields[0].name]);
       } else if (notInitFinalFields.length == 2) {
         analysisError = _errorReporter.newErrorWithProperties(
             StaticWarningCode.FINAL_NOT_INITIALIZED_CONSTRUCTOR_2,
-            node.returnType, [
+            constructor.returnType, [
           notInitFinalFields[0].name,
           notInitFinalFields[1].name
         ]);
       } else {
         analysisError = _errorReporter.newErrorWithProperties(
             StaticWarningCode.FINAL_NOT_INITIALIZED_CONSTRUCTOR_3_PLUS,
-            node.returnType, [
+            constructor.returnType, [
           notInitFinalFields[0].name,
           notInitFinalFields[1].name,
           notInitFinalFields.length - 2
         ]);
       }
       analysisError.setProperty(
           ErrorProperty.NOT_INITIALIZED_FIELDS, notInitFinalFields);
       _errorReporter.reportError(analysisError);
     }
     return foundError;
@@ skipping 296 matching lines @@
     for (ExecutableElement overriddenElement in overriddenExecutables) {
       if (_checkForAllInvalidOverrideErrorCodes(executableElement,
           overriddenElement, parameters, parameterLocations, errorNameTarget)) {
         return true;
       }
     }
     return false;
   }
 
   /**
-   * Check the given [field] declaration against override-error codes.
+   * Check the given field [declaration] against override-error codes.
    *
    * See [_checkForAllInvalidOverrideErrorCodes].
    */
-  bool _checkForAllInvalidOverrideErrorCodesForField(FieldDeclaration node) {
-    if (_enclosingClass == null || node.isStatic) {
+  bool _checkForAllInvalidOverrideErrorCodesForField(
+      FieldDeclaration declaration) {
+    if (_enclosingClass == null || declaration.isStatic) {
       return false;
     }
     bool hasProblems = false;
-    VariableDeclarationList fields = node.fields;
+    VariableDeclarationList fields = declaration.fields;
     for (VariableDeclaration field in fields.variables) {
       FieldElement element = field.element as FieldElement;
       if (element == null) {
         continue;
       }
       PropertyAccessorElement getter = element.getter;
       PropertyAccessorElement setter = element.setter;
       SimpleIdentifier fieldName = field.name;
       if (getter != null) {
         if (_checkForAllInvalidOverrideErrorCodesForExecutable(getter,
             ParameterElementImpl.EMPTY_ARRAY, AstNode.EMPTY_LIST, fieldName)) {
           hasProblems = true;
         }
       }
       if (setter != null) {
         if (_checkForAllInvalidOverrideErrorCodesForExecutable(
             setter, setter.parameters, <AstNode>[fieldName], fieldName)) {
           hasProblems = true;
         }
       }
     }
     return hasProblems;
   }
 
   /**
    * Check the given [method] declaration against override-error codes.
    *
    * See [_checkForAllInvalidOverrideErrorCodes].
    */
-  bool _checkForAllInvalidOverrideErrorCodesForMethod(MethodDeclaration node) {
+  bool _checkForAllInvalidOverrideErrorCodesForMethod(
+      MethodDeclaration method) {
     if (_enclosingClass == null ||
-        node.isStatic ||
-        node.body is NativeFunctionBody) {
+        method.isStatic ||
+        method.body is NativeFunctionBody) {
       return false;
     }
-    ExecutableElement executableElement = node.element;
+    ExecutableElement executableElement = method.element;
     if (executableElement == null) {
       return false;
     }
-    SimpleIdentifier methodName = node.name;
+    SimpleIdentifier methodName = method.name;
     if (methodName.isSynthetic) {
       return false;
     }
-    FormalParameterList formalParameterList = node.parameters;
+    FormalParameterList formalParameterList = method.parameters;
     NodeList<FormalParameter> parameterList =
         formalParameterList != null ? formalParameterList.parameters : null;
     List<AstNode> parameters =
         parameterList != null ? new List.from(parameterList) : null;
     return _checkForAllInvalidOverrideErrorCodesForExecutable(executableElement,
         executableElement.parameters, parameters, methodName);
   }
 
   /**
    * Verify that all classes of the given [withClause] are valid.
@@ skipping 35 matching lines @@
     return problemReported;
   }
 
   /**
    * Check for errors related to the redirected constructors.
    *
    * See [StaticWarningCode.REDIRECT_TO_INVALID_RETURN_TYPE],
    * [StaticWarningCode.REDIRECT_TO_INVALID_FUNCTION_TYPE], and
    * [StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR].
    */
-  bool _checkForAllRedirectConstructorErrorCodes(ConstructorDeclaration node) {
+  bool _checkForAllRedirectConstructorErrorCodes(
+      ConstructorDeclaration declaration) {
     //
     // Prepare redirected constructor node
     //
-    ConstructorName redirectedConstructor = node.redirectedConstructor;
+    ConstructorName redirectedConstructor = declaration.redirectedConstructor;
     if (redirectedConstructor == null) {
       return false;
     }
     //
     // Prepare redirected constructor type
     //
     ConstructorElement redirectedElement = redirectedConstructor.staticElement;
     if (redirectedElement == null) {
       //
       // If the element is null, we check for the
       // REDIRECT_TO_MISSING_CONSTRUCTOR case
       //
       TypeName constructorTypeName = redirectedConstructor.type;
       DartType redirectedType = constructorTypeName.type;
       if (redirectedType != null &&
           redirectedType.element != null &&
           !redirectedType.isDynamic) {
         //
         // Prepare the constructor name
         //
         String constructorStrName = constructorTypeName.name.name;
         if (redirectedConstructor.name != null) {
           constructorStrName += ".${redirectedConstructor.name.name}";
         }
-        ErrorCode errorCode = (node.constKeyword != null
+        ErrorCode errorCode = (declaration.constKeyword != null
             ? CompileTimeErrorCode.REDIRECT_TO_MISSING_CONSTRUCTOR
             : StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR);
         _errorReporter.reportErrorForNode(errorCode, redirectedConstructor, [
           constructorStrName,
           redirectedType.displayName
         ]);
         return true;
       }
       return false;
     }
     FunctionType redirectedType = redirectedElement.type;
     DartType redirectedReturnType = redirectedType.returnType;
     //
     // Report specific problem when return type is incompatible
     //
-    FunctionType constructorType = node.element.type;
+    FunctionType constructorType = declaration.element.type;
     DartType constructorReturnType = constructorType.returnType;
     if (!redirectedReturnType.isAssignableTo(constructorReturnType)) {
       _errorReporter.reportErrorForNode(
           StaticWarningCode.REDIRECT_TO_INVALID_RETURN_TYPE,
           redirectedConstructor, [redirectedReturnType, constructorReturnType]);
       return true;
     }
     //
     // Check parameters
     //
@@ skipping 14 matching lines @@
    * constructor and the return type is not assignable to `null`; that is, we
    * don't have `return;` if the enclosing method has a return type.
    *
    * Check that the return type matches the type of the declared return type in
    * the enclosing method or function.
    *
    * See [CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR],
    * [StaticWarningCode.RETURN_WITHOUT_VALUE], and
    * [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE].
    */
-  bool _checkForAllReturnStatementErrorCodes(ReturnStatement node) {
+  bool _checkForAllReturnStatementErrorCodes(ReturnStatement statement) {
     FunctionType functionType =
         _enclosingFunction == null ? null : _enclosingFunction.type;
     DartType expectedReturnType = functionType == null
         ? DynamicTypeImpl.instance
         : functionType.returnType;
-    Expression returnExpression = node.expression;
+    Expression returnExpression = statement.expression;
     // RETURN_IN_GENERATIVE_CONSTRUCTOR
     bool isGenerativeConstructor = _enclosingFunction is ConstructorElement &&
         !(_enclosingFunction as ConstructorElement).isFactory;
     if (isGenerativeConstructor) {
       if (returnExpression == null) {
         return false;
       }
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR,
           returnExpression);
       return true;
     }
     // RETURN_WITHOUT_VALUE
     if (returnExpression == null) {
       if (_inGenerator ||
           _computeReturnTypeForMethod(null)
               .isAssignableTo(expectedReturnType)) {
         return false;
       }
       _hasReturnWithoutValue = true;
       _errorReporter.reportErrorForNode(
-          StaticWarningCode.RETURN_WITHOUT_VALUE, node);
+          StaticWarningCode.RETURN_WITHOUT_VALUE, statement);
       return true;
     } else if (_inGenerator) {
       // RETURN_IN_GENERATOR
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.RETURN_IN_GENERATOR, node);
+          CompileTimeErrorCode.RETURN_IN_GENERATOR, statement);
     }
     // RETURN_OF_INVALID_TYPE
     return _checkForReturnOfInvalidType(returnExpression, expectedReturnType);
   }
 
   /**
    * Verify that the export namespace of the given export [directive] does not
    * export any name already exported by another export directive. The
    * [exportElement] is the [ExportElement] retrieved from the node. If the
    * element in the node was `null`, then this method is not called. The
    * [exportedLibrary] is the library element containing the exported element.
    *
    * See [CompileTimeErrorCode.AMBIGUOUS_EXPORT].
    */
-  bool _checkForAmbiguousExport(ExportDirective node,
+  bool _checkForAmbiguousExport(ExportDirective directive,
       ExportElement exportElement, LibraryElement exportedLibrary) {
     if (exportedLibrary == null) {
       return false;
     }
     // check exported names
     Namespace namespace =
         new NamespaceBuilder().createExportNamespaceForDirective(exportElement);
     Map<String, Element> definedNames = namespace.definedNames;
     for (String name in definedNames.keys) {
       Element element = definedNames[name];
       Element prevElement = _exportedElements[name];
       if (element != null && prevElement != null && prevElement != element) {
         _errorReporter.reportErrorForNode(CompileTimeErrorCode.AMBIGUOUS_EXPORT,
-            node, [
+            directive, [
           name,
           prevElement.library.definingCompilationUnit.displayName,
           element.library.definingCompilationUnit.displayName
         ]);
         return true;
       } else {
         _exportedElements[name] = element;
       }
     }
     return false;
   }
 
   /**
    * Verify that the given [expression] can be assigned to its corresponding
    * parameters. The [expectedStaticType] is the expected static type of the
    * parameter. The [actualStaticType] is the actual static type of the
-   * argument. The [expectedPropagatedType] is the expected propagated type of
-   * the parameter, may be `null`. The [actualPropagatedType] is the expected
-   * propagated type of the parameter, may be `null`.
+   * argument.
    *
    * This method corresponds to
    * [BestPracticesVerifier.checkForArgumentTypeNotAssignable].
    *
    * See [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE],
    * [StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE],
    * [StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE], and
@@ skipping 30 matching lines @@
     }
     ParameterElement staticParameterElement = argument.staticParameterElement;
     DartType staticParameterType =
         staticParameterElement == null ? null : staticParameterElement.type;
     return _checkForArgumentTypeNotAssignableWithExpectedTypes(argument,
         staticParameterType, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
   }
 
   /**
    * Verify that the given [expression] can be assigned to its corresponding
-   * parameters. The [expectedStaticType] is the expected static type. The
-   * [expectedPropagatedType] is the expected propagated type, may be `null`.
+   * parameters. The [expectedStaticType] is the expected static type.
    *
    * This method corresponds to
    * [BestPracticesVerifier.checkForArgumentTypeNotAssignableWithExpectedTypes].
    *
    * See [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE],
    * [StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE],
    * [StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE], and
@@ skipping 127 matching lines @@
     }
     return false;
   }
 
   /**
    * Verify that the given [switchCase] is terminated with 'break', 'continue',
    * 'return' or 'throw'.
    *
    * see [StaticWarningCode.CASE_BLOCK_NOT_TERMINATED].
    */
-  bool _checkForCaseBlockNotTerminated(SwitchCase node) {
-    NodeList<Statement> statements = node.statements;
+  bool _checkForCaseBlockNotTerminated(SwitchCase switchCase) {
+    NodeList<Statement> statements = switchCase.statements;
     if (statements.isEmpty) {
       // fall-through without statements at all
-      AstNode parent = node.parent;
+      AstNode parent = switchCase.parent;
       if (parent is SwitchStatement) {
         SwitchStatement switchStatement = parent;
         NodeList<SwitchMember> members = switchStatement.members;
-        int index = members.indexOf(node);
+        int index = members.indexOf(switchCase);
         if (index != -1 && index < members.length - 1) {
           return false;
         }
       }
       // no other switch member after this one
     } else {
       Statement statement = statements[statements.length - 1];
       // terminated with statement
       if (statement is BreakStatement ||
           statement is ContinueStatement ||
           statement is ReturnStatement) {
         return false;
       }
       // terminated with 'throw' expression
       if (statement is ExpressionStatement) {
         Expression expression = statement.expression;
         if (expression is ThrowExpression) {
           return false;
         }
       }
     }
     // report error
     _errorReporter.reportErrorForToken(
-        StaticWarningCode.CASE_BLOCK_NOT_TERMINATED, node.keyword);
+        StaticWarningCode.CASE_BLOCK_NOT_TERMINATED, switchCase.keyword);
     return true;
   }
 
   /**
    * Verify that the switch cases in the given switch [statement] are terminated
    * with 'break', 'continue', 'return' or 'throw'.
    *
    * See [StaticWarningCode.CASE_BLOCK_NOT_TERMINATED].
    */
-  bool _checkForCaseBlocksNotTerminated(SwitchStatement node) {
+  bool _checkForCaseBlocksNotTerminated(SwitchStatement statement) {
     bool foundError = false;
-    NodeList<SwitchMember> members = node.members;
+    NodeList<SwitchMember> members = statement.members;
     int lastMember = members.length - 1;
     for (int i = 0; i < lastMember; i++) {
       SwitchMember member = members[i];
       if (member is SwitchCase && _checkForCaseBlockNotTerminated(member)) {
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
    * Verify that the given [method] declaration is abstract only if the
    * enclosing class is also abstract.
    *
    * See [StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER].
    */
-  bool _checkForConcreteClassWithAbstractMember(MethodDeclaration node) {
-    if (node.isAbstract &&
+  bool _checkForConcreteClassWithAbstractMember(MethodDeclaration method) {
+    if (method.isAbstract &&
         _enclosingClass != null &&
         !_enclosingClass.isAbstract) {
-      SimpleIdentifier nameNode = node.name;
+      SimpleIdentifier nameNode = method.name;
       String memberName = nameNode.name;
       ExecutableElement overriddenMember;
-      if (node.isGetter) {
+      if (method.isGetter) {
         overriddenMember = _enclosingClass.lookUpInheritedConcreteGetter(
             memberName, _currentLibrary);
-      } else if (node.isSetter) {
+      } else if (method.isSetter) {
         overriddenMember = _enclosingClass.lookUpInheritedConcreteSetter(
             memberName, _currentLibrary);
       } else {
         overriddenMember = _enclosingClass.lookUpInheritedConcreteMethod(
             memberName, _currentLibrary);
       }
       if (overriddenMember == null) {
         _errorReporter.reportErrorForNode(
             StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER, nameNode, [
           memberName,
           _enclosingClass.displayName
         ]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * Verify all possible conflicts of the given [constructor]'s name with other
    * constructors and members of the same class. The [constructorElement] is the
    * constructor's element.
    *
    * See [CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT],
    * [CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME],
    * [CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD], and
    * [CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD].
    */
   bool _checkForConflictingConstructorNameAndMember(
-      ConstructorDeclaration node, ConstructorElement constructorElement) {
-    SimpleIdentifier constructorName = node.name;
+      ConstructorDeclaration constructor,
+      ConstructorElement constructorElement) {
+    SimpleIdentifier constructorName = constructor.name;
     String name = constructorElement.name;
     ClassElement classElement = constructorElement.enclosingElement;
     // constructors
     List<ConstructorElement> constructors = classElement.constructors;
     for (ConstructorElement otherConstructor in constructors) {
       if (identical(otherConstructor, constructorElement)) {
         continue;
       }
       if (name == otherConstructor.name) {
         if (name == null || name.length == 0) {
           _errorReporter.reportErrorForNode(
-              CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT, node);
+              CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT, constructor);
         } else {
           _errorReporter.reportErrorForNode(
-              CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME, node, [name]);
+              CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME, constructor,
+              [name]);
         }
         return true;
       }
     }
     // conflict with class member
     if (constructorName != null &&
         constructorElement != null &&
         !constructorName.isSynthetic) {
       // fields
       FieldElement field = classElement.getField(name);
       if (field != null) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD, node,
-            [name]);
+            CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD,
+            constructor, [name]);
         return true;
       }
       // methods
       MethodElement method = classElement.getMethod(name);
       if (method != null) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD, node,
-            [name]);
+            CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD,
+            constructor, [name]);
         return true;
       }
     }
     return false;
   }
 
   /**
-   * Verify that the [enclosingClass] does not have a method and getter pair
+   * Verify that the [_enclosingClass] does not have a method and getter pair
    * with the same name on, via inheritance.
    *
    * See [CompileTimeErrorCode.CONFLICTING_GETTER_AND_METHOD], and
    * [CompileTimeErrorCode.CONFLICTING_METHOD_AND_GETTER].
    */
   bool _checkForConflictingGetterAndMethod() {
     if (_enclosingClass == null) {
       return false;
     }
     bool hasProblem = false;
@@ skipping 36 matching lines @@
         _enclosingClass.displayName,
         inherited.enclosingElement.displayName,
         name
       ]);
     }
     // done
     return hasProblem;
   }
 
   /**
-   * Verify that the superclass of the [enclosingClass] does not declare
+   * Verify that the superclass of the [_enclosingClass] does not declare
    * accessible static members with the same name as the instance
-   * getters/setters declared in [enclosingClass].
+   * getters/setters declared in [_enclosingClass].
    *
    * See [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER], and
    * [StaticWarningCode.CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER].
    */
   bool _checkForConflictingInstanceGetterAndSuperclassMember() {
     if (_enclosingClass == null) {
       return false;
     }
     InterfaceType enclosingType = _enclosingClass.type;
     // check every accessor
@@ skipping 52 matching lines @@
 
   /**
    * Verify that the enclosing class does not have a setter with the same name
    * as the given instance method declaration.
    *
    * TODO(jwren) add other "conflicting" error codes into algorithm/ data
    * structure.
    *
    * See [StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER].
    */
-  bool _checkForConflictingInstanceMethodSetter(ClassDeclaration node) {
+  bool _checkForConflictingInstanceMethodSetter(ClassDeclaration declaration) {
     // Reference all of the class members in this class.
-    NodeList<ClassMember> classMembers = node.members;
+    NodeList<ClassMember> classMembers = declaration.members;
     if (classMembers.isEmpty) {
       return false;
     }
     // Create a HashMap to track conflicting members, and then loop through
     // members in the class to construct the HashMap, at the same time,
     // look for violations.  Don't add members if they are part of a conflict,
     // this prevents multiple warnings for one issue.
     bool foundError = false;
     HashMap<String, ClassMember> memberHashMap =
         new HashMap<String, ClassMember>();
@@ skipping 71 matching lines @@
     return foundError;
   }
 
   /**
    * Verify that the enclosing class does not have an instance member with the
    * same name as the given static [method] declaration.
    *
    * See [StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER].
    */
   bool _checkForConflictingStaticGetterAndInstanceSetter(
-      MethodDeclaration node) {
-    if (!node.isStatic) {
+      MethodDeclaration method) {
+    if (!method.isStatic) {
       return false;
     }
     // prepare name
-    SimpleIdentifier nameNode = node.name;
+    SimpleIdentifier nameNode = method.name;
     if (nameNode == null) {
       return false;
     }
     String name = nameNode.name;
     // prepare enclosing type
     if (_enclosingClass == null) {
       return false;
     }
     InterfaceType enclosingType = _enclosingClass.type;
     // try to find setter
@@ skipping 16 matching lines @@
     return true;
   }
 
   /**
    * Verify that the enclosing class does not have an instance member with the
    * same name as the given static [method] declaration.
    *
    * See [StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER].
    */
   bool _checkForConflictingStaticSetterAndInstanceMember(
-      MethodDeclaration node) {
-    if (!node.isStatic) {
+      MethodDeclaration method) {
+    if (!method.isStatic) {
       return false;
     }
     // prepare name
-    SimpleIdentifier nameNode = node.name;
+    SimpleIdentifier nameNode = method.name;
     if (nameNode == null) {
       return false;
     }
     String name = nameNode.name;
     // prepare enclosing type
     if (_enclosingClass == null) {
       return false;
     }
     InterfaceType enclosingType = _enclosingClass.type;
     // try to find member
@@ skipping 22 matching lines @@
     return true;
   }
 
   /**
    * Verify all conflicts between type variable and enclosing class.
    * TODO(scheglov)
    *
    * See [CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_CLASS], and
    * [CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER].
    */
-  bool _checkForConflictingTypeVariableErrorCodes(ClassDeclaration node) {
+  bool _checkForConflictingTypeVariableErrorCodes(
+      ClassDeclaration declaration) {
     bool problemReported = false;
     for (TypeParameterElement typeParameter in _enclosingClass.typeParameters) {
       String name = typeParameter.name;
       // name is same as the name of the enclosing class
       if (_enclosingClass.name == name) {
         _errorReporter.reportErrorForOffset(
             CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_CLASS,
             typeParameter.nameOffset, name.length, [name]);
         problemReported = true;
       }
       // check members
       if (_enclosingClass.getMethod(name) != null ||
           _enclosingClass.getGetter(name) != null ||
           _enclosingClass.getSetter(name) != null) {
         _errorReporter.reportErrorForOffset(
             CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER,
             typeParameter.nameOffset, name.length, [name]);
         problemReported = true;
       }
     }
     return problemReported;
   }
 
   /**
    * Verify that if the given [constructor] declaration is 'const' then there
    * are no invocations of non-'const' super constructors.
    *
    * See [CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER].
    */
-  bool _checkForConstConstructorWithNonConstSuper(ConstructorDeclaration node) {
+  bool _checkForConstConstructorWithNonConstSuper(
+      ConstructorDeclaration constructor) {
     if (!_isEnclosingConstructorConst) {
       return false;
     }
     // OK, const factory, checked elsewhere
-    if (node.factoryKeyword != null) {
+    if (constructor.factoryKeyword != null) {
       return false;
     }
     // check for mixins
     if (_enclosingClass.mixins.length != 0) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_MIXIN, node.returnType);
+          CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_MIXIN,
+          constructor.returnType);
       return true;
     }
     // try to find and check super constructor invocation
-    for (ConstructorInitializer initializer in node.initializers) {
+    for (ConstructorInitializer initializer in constructor.initializers) {
       if (initializer is SuperConstructorInvocation) {
         SuperConstructorInvocation superInvocation = initializer;
         ConstructorElement element = superInvocation.staticElement;
         if (element == null || element.isConst) {
           return false;
         }
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER,
             superInvocation, [element.enclosingElement.displayName]);
         return true;
@@ skipping 11 matching lines @@
         supertype.element.unnamedConstructor;
     if (unnamedConstructor == null) {
       return false;
     }
     if (unnamedConstructor.isConst) {
       return false;
     }
     // default constructor is not 'const', report problem
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER,
-        node.returnType, [supertype.displayName]);
+        constructor.returnType, [supertype.displayName]);
     return true;
   }
 
   /**
-   * Verify that if the given constructor [declaration] is 'const' then there
+   * Verify that if the given [constructor] declaration is 'const' then there
    * are no non-final instance variable. The [constructorElement] is the
    * constructor element.
    *
    * See [CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD].
    */
   bool _checkForConstConstructorWithNonFinalField(
-      ConstructorDeclaration node, ConstructorElement constructorElement) {
+      ConstructorDeclaration constructor,
+      ConstructorElement constructorElement) {
     if (!_isEnclosingConstructorConst) {
       return false;
     }
     // check if there is non-final field
     ClassElement classElement = constructorElement.enclosingElement;
     if (!classElement.hasNonFinalField) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD, node);
+        CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD,
+        constructor);
     return true;
   }
 
   /**
    * Verify that the given 'const' instance creation [expression] is not
    * creating a deferred type. The [constructorName] is the constructor name,
    * always non-`null`. The [typeName] is the name of the type defining the
    * constructor, always non-`null`.
    *
    * See [CompileTimeErrorCode.CONST_DEFERRED_CLASS].
    */
-  bool _checkForConstDeferredClass(InstanceCreationExpression node,
+  bool _checkForConstDeferredClass(InstanceCreationExpression expression,
       ConstructorName constructorName, TypeName typeName) {
     if (typeName.isDeferred) {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.CONST_DEFERRED_CLASS, constructorName,
           [typeName.name.name]);
       return true;
     }
     return false;
   }
 
   /**
    * Verify that the given throw [expression] is not enclosed in a 'const'
    * constructor declaration.
    *
    * See [CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION].
    */
-  bool _checkForConstEvalThrowsException(ThrowExpression node) {
+  bool _checkForConstEvalThrowsException(ThrowExpression expression) {
     if (_isEnclosingConstructorConst) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION, node);
+          CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION, expression);
       return true;
     }
     return false;
   }
 
   /**
    * Verify that the given normal formal [parameter] is not 'const'.
    *
    * See [CompileTimeErrorCode.CONST_FORMAL_PARAMETER].
    */
-  bool _checkForConstFormalParameter(NormalFormalParameter node) {
-    if (node.isConst) {
+  bool _checkForConstFormalParameter(NormalFormalParameter parameter) {
+    if (parameter.isConst) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.CONST_FORMAL_PARAMETER, node);
+          CompileTimeErrorCode.CONST_FORMAL_PARAMETER, parameter);
       return true;
     }
     return false;
   }
 
   /**
    * Verify that the given instance creation [expression] is not being invoked
    * on an abstract class. The [typeName] is the [TypeName] of the
    * [ConstructorName] from the [InstanceCreationExpression], this is the AST
    * node that the error is attached to. The [type] is the type being
    * constructed with this [InstanceCreationExpression].
    *
    * See [StaticWarningCode.CONST_WITH_ABSTRACT_CLASS], and
    * [StaticWarningCode.NEW_WITH_ABSTRACT_CLASS].
    */
   bool _checkForConstOrNewWithAbstractClass(
-      InstanceCreationExpression node, TypeName typeName, InterfaceType type) {
+      InstanceCreationExpression expression, TypeName typeName,
+      InterfaceType type) {
     if (type.element.isAbstract) {
-      ConstructorElement element = node.staticElement;
+      ConstructorElement element = expression.staticElement;
       if (element != null && !element.isFactory) {
-        if ((node.keyword as sc.KeywordToken).keyword == sc.Keyword.CONST) {
+        if ((expression.keyword as sc.KeywordToken).keyword ==
+            sc.Keyword.CONST) {
           _errorReporter.reportErrorForNode(
               StaticWarningCode.CONST_WITH_ABSTRACT_CLASS, typeName);
         } else {
           _errorReporter.reportErrorForNode(
               StaticWarningCode.NEW_WITH_ABSTRACT_CLASS, typeName);
         }
         return true;
       }
     }
     return false;
   }
 
   /**
    * Verify that the given instance creation [expression] is not being invoked
    * on an enum. The [typeName] is the [TypeName] of the [ConstructorName] from
    * the [InstanceCreationExpression], this is the AST node that the error is
    * attached to. The [type] is the type being constructed with this
    * [InstanceCreationExpression].
    *
    * See [CompileTimeErrorCode.INSTANTIATE_ENUM].
    */
-  bool _checkForConstOrNewWithEnum(
-      InstanceCreationExpression node, TypeName typeName, InterfaceType type) {
+  bool _checkForConstOrNewWithEnum(InstanceCreationExpression expression,
+      TypeName typeName, InterfaceType type) {
     if (type.element.isEnum) {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.INSTANTIATE_ENUM, typeName);
       return true;
     }
     return false;
   }
 
   /**
    * Verify that the given 'const' instance creation [expression] is not being
    * invoked on a constructor that is not 'const'.
    *
    * This method assumes that the instance creation was tested to be 'const'
    * before being called.
    *
    * See [CompileTimeErrorCode.CONST_WITH_NON_CONST].
    */
-  bool _checkForConstWithNonConst(InstanceCreationExpression node) {
-    ConstructorElement constructorElement = node.staticElement;
+  bool _checkForConstWithNonConst(InstanceCreationExpression expression) {
+    ConstructorElement constructorElement = expression.staticElement;
     if (constructorElement != null && !constructorElement.isConst) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.CONST_WITH_NON_CONST, node);
+          CompileTimeErrorCode.CONST_WITH_NON_CONST, expression);
       return true;
     }
     return false;
   }
 
   /**
    * Verify that the given [typeName] does not reference any type parameters.
    *
    * See [CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS].
    */
@@ skipping 31 matching lines @@
    * invoked on the resolved constructor. The [constructorName] is the
    * constructor name, always non-`null`. The [typeName] is the name of the type
    * defining the constructor, always non-`null`.
    *
    * This method assumes that the instance creation was tested to be 'const'
    * before being called.
    *
    * See [CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR], and
    * [CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT].
    */
-  bool _checkForConstWithUndefinedConstructor(InstanceCreationExpression node,
-      ConstructorName constructorName, TypeName typeName) {
+  bool _checkForConstWithUndefinedConstructor(
+      InstanceCreationExpression expression, ConstructorName constructorName,
+      TypeName typeName) {
     // OK if resolved
-    if (node.staticElement != null) {
+    if (expression.staticElement != null) {
       return false;
     }
     DartType type = typeName.type;
     if (type is InterfaceType) {
       ClassElement element = type.element;
       if (element != null && element.isEnum) {
         // We have already reported the error.
         return false;
       }
     }
@@ skipping 13 matching lines @@
     }
     return true;
   }
 
   /**
    * Verify that there are no default parameters in the given function type
    * [alias].
    *
    * See [CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS].
    */
-  bool _checkForDefaultValueInFunctionTypeAlias(FunctionTypeAlias node) {
+  bool _checkForDefaultValueInFunctionTypeAlias(FunctionTypeAlias alias) {
     bool result = false;
-    FormalParameterList formalParameterList = node.parameters;
+    FormalParameterList formalParameterList = alias.parameters;
     NodeList<FormalParameter> parameters = formalParameterList.parameters;
     for (FormalParameter formalParameter in parameters) {
       if (formalParameter is DefaultFormalParameter) {
         DefaultFormalParameter defaultFormalParameter = formalParameter;
         if (defaultFormalParameter.defaultValue != null) {
           _errorReporter.reportErrorForNode(
-              CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS, node);
+              CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS, alias);
           result = true;
         }
       }
     }
     return result;
   }
 
   /**
    * Verify that the given default formal [parameter] is not part of a function
    * typed parameter.
    *
    * See [CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER].
    */
   bool _checkForDefaultValueInFunctionTypedParameter(
-      DefaultFormalParameter node) {
+      DefaultFormalParameter parameter) {
     // OK, not in a function typed parameter.
     if (!_isInFunctionTypedFormalParameter) {
       return false;
     }
     // OK, no default value.
-    if (node.defaultValue == null) {
+    if (parameter.defaultValue == null) {
       return false;
     }
     // Report problem.
     _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER, node);
+        CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER,
+        parameter);
     return true;
   }
 
   /**
    * Verify that any deferred imports in the given compilation [unit] have a
    * unique prefix.
    *
    * See [CompileTimeErrorCode.SHARED_DEFERRED_PREFIX].
    */
-  bool _checkForDeferredPrefixCollisions(CompilationUnit node) {
+  bool _checkForDeferredPrefixCollisions(CompilationUnit unit) {
     bool foundError = false;
-    NodeList<Directive> directives = node.directives;
+    NodeList<Directive> directives = unit.directives;
     int count = directives.length;
     if (count > 0) {
       HashMap<PrefixElement, List<ImportDirective>> prefixToDirectivesMap =
           new HashMap<PrefixElement, List<ImportDirective>>();
       for (int i = 0; i < count; i++) {
         Directive directive = directives[i];
         if (directive is ImportDirective) {
           ImportDirective importDirective = directive;
           SimpleIdentifier prefix = importDirective.prefix;
           if (prefix != null) {
@@ skipping 82 matching lines @@
     return true;
   }
 
   /**
    * Verify that if the given list [literal] has type arguments then there is
    * exactly one. The [typeArguments] are the type arguments.
    *
    * See [StaticTypeWarningCode.EXPECTED_ONE_LIST_TYPE_ARGUMENTS].
    */
   bool _checkForExpectedOneListTypeArgument(
-      ListLiteral node, TypeArgumentList typeArguments) {
+      ListLiteral literal, TypeArgumentList typeArguments) {
     // check number of type arguments
     int num = typeArguments.arguments.length;
     if (num == 1) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
         StaticTypeWarningCode.EXPECTED_ONE_LIST_TYPE_ARGUMENTS, typeArguments,
         [num]);
     return true;
   }
 
   /**
-   * Verify that the given export ([node]) has a unique name among other
+   * Verify that the given export [directive] has a unique name among other
    * exported libraries. The [exportElement] is the [ExportElement] retrieved
    * from the node, if the element in the node was `null`, then this method is
    * not called. The [exportedLibrary] is the library element containing the
    * exported element.
    *
    * See [CompileTimeErrorCode.EXPORT_DUPLICATED_LIBRARY_NAME].
    */
-  bool _checkForExportDuplicateLibraryName(ExportDirective node,
+  bool _checkForExportDuplicateLibraryName(ExportDirective directive,
       ExportElement exportElement, LibraryElement exportedLibrary) {
     if (exportedLibrary == null) {
       return false;
     }
     String name = exportedLibrary.name;
     // check if there is other exported library with the same name
     LibraryElement prevLibrary = _nameToExportElement[name];
     if (prevLibrary != null) {
       if (prevLibrary != exportedLibrary) {
         if (name.isEmpty) {
           _errorReporter.reportErrorForNode(
-              StaticWarningCode.EXPORT_DUPLICATED_LIBRARY_UNNAMED, node, [
+              StaticWarningCode.EXPORT_DUPLICATED_LIBRARY_UNNAMED, directive, [
             prevLibrary.definingCompilationUnit.displayName,
             exportedLibrary.definingCompilationUnit.displayName
           ]);
         } else {
           _errorReporter.reportErrorForNode(
-              StaticWarningCode.EXPORT_DUPLICATED_LIBRARY_NAMED, node, [
+              StaticWarningCode.EXPORT_DUPLICATED_LIBRARY_NAMED, directive, [
             prevLibrary.definingCompilationUnit.displayName,
             exportedLibrary.definingCompilationUnit.displayName,
             name
           ]);
         }
         return true;
       }
     } else {
       _nameToExportElement[name] = exportedLibrary;
     }
     // OK
     return false;
   }
 
   /**
    * Check that if the visiting library is not system, then any given library
    * should not be SDK internal library. The [exportElement] is the
    * [ExportElement] retrieved from the node, if the element in the node was
    * `null`, then this method is not called.
    *
    * See [CompileTimeErrorCode.EXPORT_INTERNAL_LIBRARY].
    */
   bool _checkForExportInternalLibrary(
-      ExportDirective node, ExportElement exportElement) {
+      ExportDirective directive, ExportElement exportElement) {
     if (_isInSystemLibrary) {
       return false;
     }
     // should be private
     DartSdk sdk = _currentLibrary.context.sourceFactory.dartSdk;
     String uri = exportElement.uri;
     SdkLibrary sdkLibrary = sdk.getSdkLibrary(uri);
     if (sdkLibrary == null) {
       return false;
     }
     if (!sdkLibrary.isInternal) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.EXPORT_INTERNAL_LIBRARY, node, [node.uri]);
+        CompileTimeErrorCode.EXPORT_INTERNAL_LIBRARY, directive,
+        [directive.uri]);
     return true;
   }
 
   /**
    * Verify that the given extends [clause] does not extend a deferred class.
    *
    * See [CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS].
    */
-  bool _checkForExtendsDeferredClass(ExtendsClause node) {
-    if (node == null) {
+  bool _checkForExtendsDeferredClass(ExtendsClause clause) {
+    if (clause == null) {
       return false;
     }
     return _checkForExtendsOrImplementsDeferredClass(
-        node.superclass, CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS);
+        clause.superclass, CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS);
   }
 
   /**
    * Verify that the given type [alias] does not extend a deferred class.
    *
    * See [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS].
    */
-  bool _checkForExtendsDeferredClassInTypeAlias(ClassTypeAlias node) {
-    if (node == null) {
+  bool _checkForExtendsDeferredClassInTypeAlias(ClassTypeAlias alias) {
+    if (alias == null) {
       return false;
     }
     return _checkForExtendsOrImplementsDeferredClass(
-        node.superclass, CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS);
+        alias.superclass, CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS);
   }
 
   /**
    * Verify that the given extends [clause] does not extend classes such as
    * 'num' or 'String'.
    *
    * See [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS].
    */
-  bool _checkForExtendsDisallowedClass(ExtendsClause node) {
-    if (node == null) {
+  bool _checkForExtendsDisallowedClass(ExtendsClause clause) {
+    if (clause == null) {
       return false;
     }
     return _checkForExtendsOrImplementsDisallowedClass(
-        node.superclass, CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS);
+        clause.superclass, CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS);
   }
 
   /**
    * Verify that the given type [alias] does not extend classes such as 'num' or
    * 'String'.
    *
    * See [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS].
    */
-  bool _checkForExtendsDisallowedClassInTypeAlias(ClassTypeAlias node) {
-    if (node == null) {
+  bool _checkForExtendsDisallowedClassInTypeAlias(ClassTypeAlias alias) {
+    if (alias == null) {
       return false;
     }
     return _checkForExtendsOrImplementsDisallowedClass(
-        node.superclass, CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS);
+        alias.superclass, CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS);
   }
 
   /**
    * Verify that the given [typeName] does not extend, implement or mixin
    * classes that are deferred.
    *
    * See [_checkForExtendsDeferredClass],
    * [_checkForExtendsDeferredClassInTypeAlias],
    * [_checkForImplementsDeferredClass],
    * [_checkForAllMixinErrorCodes],
@@ skipping 65 matching lines @@
 
   /**
    * Verify that the given constructor field [initializer] has compatible field
    * and initializer expression types. The [staticElement] is the static element
    * from the name in the [ConstructorFieldInitializer].
    *
    * See [CompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE], and
    * [StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE].
    */
   bool _checkForFieldInitializerNotAssignable(
-      ConstructorFieldInitializer node, Element staticElement) {
+      ConstructorFieldInitializer initializer, Element staticElement) {
     // prepare field element
     if (staticElement is! FieldElement) {
       return false;
     }
     FieldElement fieldElement = staticElement as FieldElement;
     // prepare field type
     DartType fieldType = fieldElement.type;
     // prepare expression type
-    Expression expression = node.expression;
+    Expression expression = initializer.expression;
     if (expression == null) {
       return false;
     }
     // test the static type of the expression
     DartType staticType = getStaticType(expression);
     if (staticType == null) {
       return false;
     }
     if (staticType.isAssignableTo(fieldType)) {
       return false;
@@ skipping 36 matching lines @@
 //        return true;
   }
 
   /**
    * Verify that the given field formal [parameter] is in a constructor
    * declaration.
    *
    * See [CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR].
    */
   bool _checkForFieldInitializingFormalRedirectingConstructor(
-      FieldFormalParameter node) {
+      FieldFormalParameter parameter) {
     ConstructorDeclaration constructor =
-        node.getAncestor((node) => node is ConstructorDeclaration);
+        parameter.getAncestor((node) => node is ConstructorDeclaration);
     if (constructor == null) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR, node);
+          CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR,
+          parameter);
       return true;
     }
     // constructor cannot be a factory
     if (constructor.factoryKeyword != null) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.FIELD_INITIALIZER_FACTORY_CONSTRUCTOR, node);
+          CompileTimeErrorCode.FIELD_INITIALIZER_FACTORY_CONSTRUCTOR,
+          parameter);
       return true;
     }
     // constructor cannot have a redirection
     for (ConstructorInitializer initializer in constructor.initializers) {
       if (initializer is RedirectingConstructorInvocation) {
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR,
-            node);
+            parameter);
         return true;
       }
     }
     // OK
     return false;
   }
 
   /**
    * Verify that the given variable declaration [list] has only initialized
    * variables if the list is final or const.
    *
    * See [CompileTimeErrorCode.CONST_NOT_INITIALIZED], and
    * [StaticWarningCode.FINAL_NOT_INITIALIZED].
    */
-  bool _checkForFinalNotInitialized(VariableDeclarationList node) {
+  bool _checkForFinalNotInitialized(VariableDeclarationList list) {
     if (_isInNativeClass) {
       return false;
     }
     bool foundError = false;
-    if (!node.isSynthetic) {
-      NodeList<VariableDeclaration> variables = node.variables;
+    if (!list.isSynthetic) {
+      NodeList<VariableDeclaration> variables = list.variables;
       for (VariableDeclaration variable in variables) {
         if (variable.initializer == null) {
-          if (node.isConst) {
+          if (list.isConst) {
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.CONST_NOT_INITIALIZED, variable.name,
                 [variable.name.name]);
-          } else if (node.isFinal) {
+          } else if (list.isFinal) {
             _errorReporter.reportErrorForNode(
                 StaticWarningCode.FINAL_NOT_INITIALIZED, variable.name,
                 [variable.name.name]);
           }
           foundError = true;
         }
       }
     }
     return foundError;
   }
 
   /**
    * Verify that final fields in the given clas [declaration] 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 of
    * [_checkForAllFinalInitializedErrorCodes].
    *
    * See [CompileTimeErrorCode.CONST_NOT_INITIALIZED], and
    * [StaticWarningCode.FINAL_NOT_INITIALIZED].
    */
-  bool _checkForFinalNotInitializedInClass(ClassDeclaration node) {
-    NodeList<ClassMember> classMembers = node.members;
+  bool _checkForFinalNotInitializedInClass(ClassDeclaration declaration) {
+    NodeList<ClassMember> classMembers = declaration.members;
     for (ClassMember classMember in classMembers) {
       if (classMember is ConstructorDeclaration) {
         return false;
       }
     }
     bool foundError = false;
     for (ClassMember classMember in classMembers) {
       if (classMember is FieldDeclaration &&
           _checkForFinalNotInitialized(classMember.fields)) {
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
    * If the current function is async, async*, or sync*, verify that its
    * declared return type is assignable to Future, Stream, or Iterable,
-   * respectively.  If not, report the error using [node].
+   * respectively.  If not, report the error using [returnType].
    */
-  void _checkForIllegalReturnType(TypeName node) {
-    if (node == null) {
+  void _checkForIllegalReturnType(TypeName returnType) {
+    if (returnType == null) {
       // No declared return type, so the return type must be dynamic, which is
       // assignable to everything.
       return;
     }
     if (_enclosingFunction.isAsynchronous) {
       if (_enclosingFunction.isGenerator) {
         if (!_enclosingFunction.returnType
             .isAssignableTo(_typeProvider.streamDynamicType)) {
           _errorReporter.reportErrorForNode(
-              StaticTypeWarningCode.ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE, node);
+              StaticTypeWarningCode.ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE,
+              returnType);
         }
       } else {
         if (!_enclosingFunction.returnType
             .isAssignableTo(_typeProvider.futureDynamicType)) {
           _errorReporter.reportErrorForNode(
-              StaticTypeWarningCode.ILLEGAL_ASYNC_RETURN_TYPE, node);
+              StaticTypeWarningCode.ILLEGAL_ASYNC_RETURN_TYPE, returnType);
         }
       }
     } else if (_enclosingFunction.isGenerator) {
       if (!_enclosingFunction.returnType
           .isAssignableTo(_typeProvider.iterableDynamicType)) {
         _errorReporter.reportErrorForNode(
-            StaticTypeWarningCode.ILLEGAL_SYNC_GENERATOR_RETURN_TYPE, node);
+            StaticTypeWarningCode.ILLEGAL_SYNC_GENERATOR_RETURN_TYPE,
+            returnType);
       }
     }
   }
 
   /**
    * Verify that the given implements [clause] does not implement classes that
    * are deferred.
    *
    * See [CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS].
    */
-  bool _checkForImplementsDeferredClass(ImplementsClause node) {
-    if (node == null) {
+  bool _checkForImplementsDeferredClass(ImplementsClause clause) {
+    if (clause == null) {
       return false;
     }
     bool foundError = false;
-    for (TypeName type in node.interfaces) {
+    for (TypeName type in clause.interfaces) {
       if (_checkForExtendsOrImplementsDeferredClass(
           type, CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS)) {
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
    * Verify that the given implements [clause] does not implement classes such
    * as 'num' or 'String'.
    *
    * See [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS].
    */
-  bool _checkForImplementsDisallowedClass(ImplementsClause node) {
-    if (node == null) {
+  bool _checkForImplementsDisallowedClass(ImplementsClause clause) {
+    if (clause == null) {
       return false;
     }
     bool foundError = false;
-    for (TypeName type in node.interfaces) {
+    for (TypeName type in clause.interfaces) {
       if (_checkForExtendsOrImplementsDisallowedClass(
           type, CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS)) {
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
    * Verify that if the given [identifier] is part of a constructor initializer,
    * then it does not implicitly reference 'this' expression.
    *
    * See [CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER], and
    * [CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC].
    * TODO(scheglov) rename thid method
    */
-  bool _checkForImplicitThisReferenceInInitializer(SimpleIdentifier node) {
+  bool _checkForImplicitThisReferenceInInitializer(
+      SimpleIdentifier identifier) {
     if (!_isInConstructorInitializer &&
         !_isInStaticMethod &&
         !_isInFactory &&
         !_isInInstanceVariableInitializer &&
         !_isInStaticVariableDeclaration) {
       return false;
     }
     // prepare element
-    Element element = node.staticElement;
+    Element element = identifier.staticElement;
     if (!(element is MethodElement || element is PropertyAccessorElement)) {
       return false;
     }
     // static element
     ExecutableElement executableElement = element as ExecutableElement;
     if (executableElement.isStatic) {
       return false;
     }
     // not a class member
     Element enclosingElement = element.enclosingElement;
     if (enclosingElement is! ClassElement) {
       return false;
     }
     // comment
-    AstNode parent = node.parent;
+    AstNode parent = identifier.parent;
     if (parent is CommentReference) {
       return false;
     }
     // qualified method invocation
     if (parent is MethodInvocation) {
       MethodInvocation invocation = parent;
-      if (identical(invocation.methodName, node) &&
+      if (identical(invocation.methodName, identifier) &&
           invocation.realTarget != null) {
         return false;
       }
     }
     // qualified property access
     if (parent is PropertyAccess) {
       PropertyAccess access = parent;
-      if (identical(access.propertyName, node) && access.realTarget != null) {
+      if (identical(access.propertyName, identifier) &&
+          access.realTarget != null) {
         return false;
       }
     }
     if (parent is PrefixedIdentifier) {
       PrefixedIdentifier prefixed = parent;
-      if (identical(prefixed.identifier, node)) {
+      if (identical(prefixed.identifier, identifier)) {
         return false;
       }
     }
     // report problem
     if (_isInStaticMethod) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC, node);
+          CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC, identifier);
     } else if (_isInFactory) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_FACTORY, node);
+          CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_FACTORY, identifier);
     } else {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER, node);
+          CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER,
+          identifier);
     }
     return true;
   }
 
   /**
    * Verify that the given import [directive] has a unique name among other
    * imported libraries. The [importElement] is the [ImportElement] retrieved
    * from the node, if the element in the node was `null`, then this method is
    * not called.
    *
    * See [CompileTimeErrorCode.IMPORT_DUPLICATED_LIBRARY_NAME].
    */
   bool _checkForImportDuplicateLibraryName(
-      ImportDirective node, ImportElement importElement) {
+      ImportDirective directive, ImportElement importElement) {
     // prepare imported library
     LibraryElement nodeLibrary = importElement.importedLibrary;
     if (nodeLibrary == null) {
       return false;
     }
     String name = nodeLibrary.name;
     // check if there is another imported library with the same name
     LibraryElement prevLibrary = _nameToImportElement[name];
     if (prevLibrary != null) {
       if (prevLibrary != nodeLibrary) {
         if (name.isEmpty) {
           _errorReporter.reportErrorForNode(
-              StaticWarningCode.IMPORT_DUPLICATED_LIBRARY_UNNAMED, node, [
+              StaticWarningCode.IMPORT_DUPLICATED_LIBRARY_UNNAMED, directive, [
             prevLibrary.definingCompilationUnit.displayName,
             nodeLibrary.definingCompilationUnit.displayName
           ]);
         } else {
           _errorReporter.reportErrorForNode(
-              StaticWarningCode.IMPORT_DUPLICATED_LIBRARY_NAMED, node, [
+              StaticWarningCode.IMPORT_DUPLICATED_LIBRARY_NAMED, directive, [
             prevLibrary.definingCompilationUnit.displayName,
             nodeLibrary.definingCompilationUnit.displayName,
             name
           ]);
         }
         return true;
       }
     } else {
       _nameToImportElement[name] = nodeLibrary;
     }
     // OK
     return false;
   }
 
   /**
    * Check that if the visiting library is not system, then any given library
    * should not be SDK internal library. The [importElement] is the
    * [ImportElement] retrieved from the node, if the element in the node was
    * `null`, then this method is not called
    *
    * See [CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY].
    */
   bool _checkForImportInternalLibrary(
-      ImportDirective node, ImportElement importElement) {
+      ImportDirective directive, ImportElement importElement) {
     if (_isInSystemLibrary) {
       return false;
     }
     // should be private
     DartSdk sdk = _currentLibrary.context.sourceFactory.dartSdk;
     String uri = importElement.uri;
     SdkLibrary sdkLibrary = sdk.getSdkLibrary(uri);
     if (sdkLibrary == null) {
       return false;
     }
     if (!sdkLibrary.isInternal) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY, node, [node.uri]);
+        CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY, directive,
+        [directive.uri]);
     return true;
   }
 
   /**
    * For each class declaration, this method is called which verifies that all
    * inherited members are inherited consistently.
    *
    * See [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE].
    */
   bool _checkForInconsistentMethodInheritance() {
@@ skipping 118 matching lines @@
         superclassType = superclassElement.supertype;
         superclassElement =
             superclassType == null ? null : superclassType.element;
       }
     }
     return false;
   }
 
   /**
    * Verify that an 'int' can be assigned to the parameter corresponding to the
-   * given [expression]. This is used for prefix and postfix expressions where
+   * given [argument]. This is used for prefix and postfix expressions where
    * the argument value is implicit.
    *
    * See [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
    */
   bool _checkForIntNotAssignable(Expression argument) {
     if (argument == null) {
       return false;
     }
     ParameterElement staticParameterElement = argument.staticParameterElement;
     DartType staticParameterType =
         staticParameterElement == null ? null : staticParameterElement.type;
     return _checkForArgumentTypeNotAssignable(argument, staticParameterType,
         _intType, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
   }
 
   /**
    * Verify that the given [annotation] isn't defined in a deferred library.
    *
    * See [CompileTimeErrorCode.INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY].
    */
-  bool _checkForInvalidAnnotationFromDeferredLibrary(Annotation node) {
-    Identifier nameIdentifier = node.name;
+  bool _checkForInvalidAnnotationFromDeferredLibrary(Annotation annotation) {
+    Identifier nameIdentifier = annotation.name;
     if (nameIdentifier is PrefixedIdentifier) {
       if (nameIdentifier.isDeferred) {
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY,
-            node.name);
+            annotation.name);
         return true;
       }
     }
     return false;
   }
 
   /**
    * Verify that the given left hand side ([lhs]) and right hand side ([rhs])
    * represent a valid assignment.
    *
@@ skipping 20 matching lines @@
   }
 
   /**
    * Given an [assignment] using a compound assignment operator, this verifies
    * that the given assignment is valid. The [lhs] is the left hand side
    * expression. The [rhs] is the right hand side expression.
    *
    * See [StaticTypeWarningCode.INVALID_ASSIGNMENT].
    */
   bool _checkForInvalidCompoundAssignment(
-      AssignmentExpression node, Expression lhs, Expression rhs) {
+      AssignmentExpression assignment, Expression lhs, Expression rhs) {
     if (lhs == null) {
       return false;
     }
     VariableElement leftVariableElement = getVariableElement(lhs);
     DartType leftType = (leftVariableElement == null)
         ? getStaticType(lhs)
         : leftVariableElement.type;
-    MethodElement invokedMethod = node.staticElement;
+    MethodElement invokedMethod = assignment.staticElement;
     if (invokedMethod == null) {
       return false;
     }
     DartType rightType = invokedMethod.type.returnType;
     if (leftType == null || rightType == null) {
       return false;
     }
     if (!rightType.isAssignableTo(leftType)) {
       _errorReporter.reportTypeErrorForNode(
           StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [rightType, leftType]);
       return true;
     }
     return false;
   }
 
   /**
    * Check the given [initializer] to ensure that the field being initialized is
    * a valid field. The [fieldName] is the field name from the
    * [ConstructorFieldInitializer]. The [staticElement] is the static element
    * from the name in the [ConstructorFieldInitializer].
    */
-  void _checkForInvalidField(ConstructorFieldInitializer node,
+  void _checkForInvalidField(ConstructorFieldInitializer initializer,
       SimpleIdentifier fieldName, Element staticElement) {
     if (staticElement is FieldElement) {
       FieldElement fieldElement = staticElement;
       if (fieldElement.isSynthetic) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD, node,
-            [fieldName]);
+            CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD,
+            initializer, [fieldName]);
       } else if (fieldElement.isStatic) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD, node,
+            CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD, initializer,
             [fieldName]);
       }
     } else {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD, node,
+          CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD, initializer,
           [fieldName]);
       return;
     }
   }
 
   /**
    * Check to see whether the given function [body] has a modifier associated
    * with it, and report it as an error if it does.
    */
   bool _checkForInvalidModifierOnBody(
       FunctionBody body, CompileTimeErrorCode errorCode) {
     sc.Token keyword = body.keyword;
     if (keyword != null) {
       _errorReporter.reportErrorForToken(errorCode, keyword, [keyword.lexeme]);
       return true;
     }
     return false;
   }
 
   /**
    * Verify that the usage of the given 'this' is valid.
    *
    * See [CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS].
    */
-  bool _checkForInvalidReferenceToThis(ThisExpression node) {
-    if (!_isThisInValidContext(node)) {
+  bool _checkForInvalidReferenceToThis(ThisExpression expression) {
+    if (!_isThisInValidContext(expression)) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS, node);
+          CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS, expression);
       return true;
     }
     return false;
   }
 
   /**
    * Checks to ensure that the given list of type [arguments] does not have a
    * type parameter as a type argument. The [errorCode] is either
    * [CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_LIST] or
    * [CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_MAP].
    */
   bool _checkForInvalidTypeArgumentInConstTypedLiteral(
       NodeList<TypeName> arguments, ErrorCode errorCode) {
     bool foundError = false;
     for (TypeName typeName in arguments) {
       if (typeName.type is TypeParameterType) {
         _errorReporter.reportErrorForNode(errorCode, typeName, [typeName.name]);
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
-   * Verify that the elements given [ListLiteral] are subtypes of the specified
+   * Verify that the elements given list [literal] are subtypes of the specified
    * element type. The [typeArguments] are the type arguments.
    *
    * See [CompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE], and
    * [StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE].
    */
   bool _checkForListElementTypeNotAssignable(
-      ListLiteral node, TypeArgumentList typeArguments) {
+      ListLiteral literal, TypeArgumentList typeArguments) {
     NodeList<TypeName> typeNames = typeArguments.arguments;
     if (typeNames.length < 1) {
       return false;
     }
     DartType listElementType = typeNames[0].type;
     // Check every list element.
     bool hasProblems = false;
-    for (Expression element in node.elements) {
-      if (node.constKeyword != null) {
+    for (Expression element in literal.elements) {
+      if (literal.constKeyword != null) {
         // TODO(paulberry): this error should be based on the actual type of the
         // list element, not the static type.  See dartbug.com/21119.
         if (_checkForArgumentTypeNotAssignableWithExpectedTypes(element,
             listElementType,
             CheckedModeCompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE)) {
           hasProblems = true;
         }
       }
       if (_checkForArgumentTypeNotAssignableWithExpectedTypes(element,
           listElementType,
           StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE)) {
         hasProblems = true;
       }
     }
     return hasProblems;
   }
 
   /**
    * Verify that the key/value of entries of the given map [literal] are
    * subtypes of the key/value types specified in the type arguments. The
    * [typeArguments] are the type arguments.
    *
    * See [CompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE],
    * [StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE], and
    * [StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE].
    */
   bool _checkForMapTypeNotAssignable(
-      MapLiteral node, TypeArgumentList typeArguments) {
+      MapLiteral literal, TypeArgumentList typeArguments) {
     // Prepare maps key/value types.
     NodeList<TypeName> typeNames = typeArguments.arguments;
     if (typeNames.length < 2) {
       return false;
     }
     DartType keyType = typeNames[0].type;
     DartType valueType = typeNames[1].type;
     // Check every map entry.
     bool hasProblems = false;
-    NodeList<MapLiteralEntry> entries = node.entries;
+    NodeList<MapLiteralEntry> entries = literal.entries;
     for (MapLiteralEntry entry in entries) {
       Expression key = entry.key;
       Expression value = entry.value;
-      if (node.constKeyword != null) {
+      if (literal.constKeyword != null) {
         // TODO(paulberry): this error should be based on the actual type of the
         // list element, not the static type.  See dartbug.com/21119.
         if (_checkForArgumentTypeNotAssignableWithExpectedTypes(key, keyType,
             CheckedModeCompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE)) {
           hasProblems = true;
         }
         if (_checkForArgumentTypeNotAssignableWithExpectedTypes(value,
             valueType,
             CheckedModeCompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE)) {
           hasProblems = true;
         }
       }
       if (_checkForArgumentTypeNotAssignableWithExpectedTypes(
           key, keyType, StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE)) {
         hasProblems = true;
       }
       if (_checkForArgumentTypeNotAssignableWithExpectedTypes(
           value, valueType, StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE)) {
         hasProblems = true;
       }
     }
     return hasProblems;
   }
 
   /**
-   * Verify that the [enclosingClass] does not define members with the same name
+   * Verify that the [_enclosingClass] does not define members with the same name
    * as the enclosing class.
    *
    * See [CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME].
    */
   bool _checkForMemberWithClassName() {
     if (_enclosingClass == null) {
       return false;
     }
     String className = _enclosingClass.name;
     if (className == null) {
@@ skipping 159 matching lines @@
     }
     return true;
   }
 
   /**
    * Verify that the given function [body] does not contain return statements
    * that both have and do not have return values.
    *
    * See [StaticWarningCode.MIXED_RETURN_TYPES].
    */
-  bool _checkForMixedReturns(BlockFunctionBody node) {
+  bool _checkForMixedReturns(BlockFunctionBody body) {
     if (_hasReturnWithoutValue) {
       return false;
     }
     int withCount = _returnsWith.length;
     int withoutCount = _returnsWithout.length;
     if (withCount > 0 && withoutCount > 0) {
       for (int i = 0; i < withCount; i++) {
         _errorReporter.reportErrorForToken(StaticWarningCode.MIXED_RETURN_TYPES,
             _returnsWith[i].returnKeyword);
       }
@@ skipping 63 matching lines @@
           [mixinElement.name]);
     }
     return false;
   }
 
   /**
    * Verify that the given [constructor] has at most one 'super' initializer.
    *
    * See [CompileTimeErrorCode.MULTIPLE_SUPER_INITIALIZERS].
    */
-  bool _checkForMultipleSuperInitializers(ConstructorDeclaration node) {
+  bool _checkForMultipleSuperInitializers(ConstructorDeclaration constructor) {
     int numSuperInitializers = 0;
-    for (ConstructorInitializer initializer in node.initializers) {
+    for (ConstructorInitializer initializer in constructor.initializers) {
       if (initializer is SuperConstructorInvocation) {
         numSuperInitializers++;
         if (numSuperInitializers > 1) {
           _errorReporter.reportErrorForNode(
               CompileTimeErrorCode.MULTIPLE_SUPER_INITIALIZERS, initializer);
         }
       }
     }
     return numSuperInitializers > 0;
   }
 
   /**
    * Checks to ensure that the given native function [body] is in SDK code.
    *
    * See [ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE].
    */
-  bool _checkForNativeFunctionBodyInNonSDKCode(NativeFunctionBody node) {
+  bool _checkForNativeFunctionBodyInNonSDKCode(NativeFunctionBody body) {
     if (!_isInSystemLibrary && !_hasExtUri) {
       _errorReporter.reportErrorForNode(
-          ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE, node);
+          ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE, body);
       return true;
     }
     return false;
   }
 
   /**
    * Verify that the given instance creation [expression] invokes an existing
    * constructor. The [constructorName] is the constructor name. The [typeName]
    * is the name of the type defining the constructor.
    *
    * This method assumes that the instance creation was tested to be 'new'
    * before being called.
    *
    * See [StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR].
    */
-  bool _checkForNewWithUndefinedConstructor(InstanceCreationExpression node,
-      ConstructorName constructorName, TypeName typeName) {
+  bool _checkForNewWithUndefinedConstructor(
+      InstanceCreationExpression expression, ConstructorName constructorName,
+      TypeName typeName) {
     // OK if resolved
-    if (node.staticElement != null) {
+    if (expression.staticElement != null) {
       return false;
     }
     DartType type = typeName.type;
     if (type is InterfaceType) {
       ClassElement element = type.element;
       if (element != null && element.isEnum) {
         // We have already reported the error.
         return false;
       }
     }
@@ skipping 15 matching lines @@
     return true;
   }
 
   /**
    * Check that if the given class [declaration] implicitly calls default
    * constructor of its superclass, there should be such default constructor -
    * implicit or explicit.
    *
    * See [CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT].
    */
-  bool _checkForNoDefaultSuperConstructorImplicit(ClassDeclaration node) {
+  bool _checkForNoDefaultSuperConstructorImplicit(
+      ClassDeclaration declaration) {
     // do nothing if mixin errors have already been reported for this class.
     ClassElementImpl enclosingClass = _enclosingClass;
     if (enclosingClass.mixinErrorsReported) {
       return false;
     }
     // do nothing if there is explicit constructor
     List<ConstructorElement> constructors = _enclosingClass.constructors;
     if (!constructors[0].isSynthetic) {
       return false;
     }
     // prepare super
     InterfaceType superType = _enclosingClass.supertype;
     if (superType == null) {
       return false;
     }
     ClassElement superElement = superType.element;
     // try to find default generative super constructor
     ConstructorElement superUnnamedConstructor =
         superElement.unnamedConstructor;
     if (superUnnamedConstructor != null) {
       if (superUnnamedConstructor.isFactory) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node.name,
+            CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, declaration.name,
             [superUnnamedConstructor]);
         return true;
       }
       if (superUnnamedConstructor.isDefaultConstructor &&
           _enclosingClass
               .isSuperConstructorAccessible(superUnnamedConstructor)) {
         return true;
       }
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT, node.name,
-        [superType.displayName]);
+        CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT,
+        declaration.name, [superType.displayName]);
     return true;
   }
 
   /**
    * Check that the given class declaration overrides all members required by
    * its superclasses and interfaces. The [classNameNode] is the
    * [SimpleIdentifier] to be used if there is a violation, this is either the
    * named from the [ClassDeclaration] or from the [ClassTypeAlias].
    *
    * See [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE],
@@ skipping 182 matching lines @@
     }
     return false;
   }
 
   /**
    * Verify that the given assert [statement] has either a 'bool' or
    * '() -> bool' input.
    *
    * See [StaticTypeWarningCode.NON_BOOL_EXPRESSION].
    */
-  bool _checkForNonBoolExpression(AssertStatement node) {
-    Expression expression = node.condition;
+  bool _checkForNonBoolExpression(AssertStatement statement) {
+    Expression expression = statement.condition;
     DartType type = getStaticType(expression);
     if (type is InterfaceType) {
       if (!type.isAssignableTo(_boolType)) {
         _errorReporter.reportErrorForNode(
             StaticTypeWarningCode.NON_BOOL_EXPRESSION, expression);
         return true;
       }
     } else if (type is FunctionType) {
       FunctionType functionType = type;
       if (functionType.typeArguments.length == 0 &&
@@ skipping 22 matching lines @@
   }
 
   /**
    * Verify the given map [literal] either:
    * * has `const modifier`
    * * has explicit type arguments
    * * is not start of the statement
    *
    * See [CompileTimeErrorCode.NON_CONST_MAP_AS_EXPRESSION_STATEMENT].
    */
-  bool _checkForNonConstMapAsExpressionStatement(MapLiteral node) {
+  bool _checkForNonConstMapAsExpressionStatement(MapLiteral literal) {
     // "const"
-    if (node.constKeyword != null) {
+    if (literal.constKeyword != null) {
       return false;
     }
     // has type arguments
-    if (node.typeArguments != null) {
+    if (literal.typeArguments != null) {
       return false;
     }
     // prepare statement
     Statement statement =
-        node.getAncestor((node) => node is ExpressionStatement);
+        literal.getAncestor((node) => node is ExpressionStatement);
     if (statement == null) {
       return false;
     }
     // OK, statement does not start with map
-    if (!identical(statement.beginToken, node.beginToken)) {
+    if (!identical(statement.beginToken, literal.beginToken)) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.NON_CONST_MAP_AS_EXPRESSION_STATEMENT, node);
+        CompileTimeErrorCode.NON_CONST_MAP_AS_EXPRESSION_STATEMENT, literal);
     return true;
   }
 
   /**
    * Verify that the given method [declaration] of operator `[]=`, has `void`
    * return type.
    *
    * See [StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR].
    */
-  bool _checkForNonVoidReturnTypeForOperator(MethodDeclaration node) {
+  bool _checkForNonVoidReturnTypeForOperator(MethodDeclaration declaration) {
     // check that []= operator
-    SimpleIdentifier name = node.name;
+    SimpleIdentifier name = declaration.name;
     if (name.name != "[]=") {
       return false;
     }
     // check return type
-    TypeName typeName = node.returnType;
+    TypeName typeName = declaration.returnType;
     if (typeName != null) {
       DartType type = typeName.type;
       if (type != null && !type.isVoid) {
         _errorReporter.reportErrorForNode(
             StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR, typeName);
       }
     }
     // no warning
     return false;
   }
 
   /**
-   * Verify the given setter has no return type or the `void` return type.
+   * Verify the [typeName], used as the return type of a setter, is valid
+   * (either `null` or the type 'void').
    *
    * See [StaticWarningCode.NON_VOID_RETURN_FOR_SETTER].
    */
   bool _checkForNonVoidReturnTypeForSetter(TypeName typeName) {
     if (typeName != null) {
       DartType type = typeName.type;
       if (type != null && !type.isVoid) {
         _errorReporter.reportErrorForNode(
             StaticWarningCode.NON_VOID_RETURN_FOR_SETTER, typeName);
       }
     }
     return false;
   }
 
   /**
    * Verify the given operator-method [declaration], does not have an optional
    * parameter. This method assumes that the method declaration was tested to be
    * an operator declaration before being called.
    *
    * See [CompileTimeErrorCode.OPTIONAL_PARAMETER_IN_OPERATOR].
    */
-  bool _checkForOptionalParameterInOperator(MethodDeclaration node) {
-    FormalParameterList parameterList = node.parameters;
+  bool _checkForOptionalParameterInOperator(MethodDeclaration declaration) {
+    FormalParameterList parameterList = declaration.parameters;
     if (parameterList == null) {
       return false;
     }
     bool foundError = false;
     NodeList<FormalParameter> formalParameters = parameterList.parameters;
     for (FormalParameter formalParameter in formalParameters) {
       if (formalParameter.kind.isOptional) {
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.OPTIONAL_PARAMETER_IN_OPERATOR,
             formalParameter);
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
    * Check that the given named optional [parameter] does not begin with '_'.
    *
    * See [CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER].
    */
-  bool _checkForPrivateOptionalParameter(FormalParameter node) {
+  bool _checkForPrivateOptionalParameter(FormalParameter parameter) {
     // should be named parameter
-    if (node.kind != ParameterKind.NAMED) {
+    if (parameter.kind != ParameterKind.NAMED) {
       return false;
     }
     // name should start with '_'
-    SimpleIdentifier name = node.identifier;
+    SimpleIdentifier name = parameter.identifier;
     if (name.isSynthetic || !StringUtilities.startsWithChar(name.name, 0x5F)) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER, node);
+        CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER, parameter);
     return true;
   }
 
   /**
    * Check whether the given constructor [declaration] is the redirecting
    * generative constructor and references itself directly or indirectly. The
    * [constructorElement] is the constructor element.
    *
    * See [CompileTimeErrorCode.RECURSIVE_CONSTRUCTOR_REDIRECT].
    */
-  bool _checkForRecursiveConstructorRedirect(
-      ConstructorDeclaration node, ConstructorElement constructorElement) {
+  bool _checkForRecursiveConstructorRedirect(ConstructorDeclaration declaration,
+      ConstructorElement constructorElement) {
     // we check generative constructor here
-    if (node.factoryKeyword != null) {
+    if (declaration.factoryKeyword != null) {
       return false;
     }
     // try to find redirecting constructor invocation and analyzer it for
     // recursion
-    for (ConstructorInitializer initializer in node.initializers) {
+    for (ConstructorInitializer initializer in declaration.initializers) {
       if (initializer is RedirectingConstructorInvocation) {
         // OK if no cycle
         if (!_hasRedirectingFactoryConstructorCycle(constructorElement)) {
           return false;
         }
         // report error
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.RECURSIVE_CONSTRUCTOR_REDIRECT, initializer);
         return true;
       }
     }
     // OK, no redirecting constructor invocation
     return false;
   }
 
   /**
    * Check whether the given constructor [declaration] has redirected
    * constructor and references itself directly or indirectly. The
-   * [constructorElement] is the constructor element.
+   * constructor [element] is the element introduced by the declaration.
    *
    * See [CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT].
    */
   bool _checkForRecursiveFactoryRedirect(
-      ConstructorDeclaration node, ConstructorElement constructorElement) {
+      ConstructorDeclaration declaration, ConstructorElement element) {
     // prepare redirected constructor
-    ConstructorName redirectedConstructorNode = node.redirectedConstructor;
+    ConstructorName redirectedConstructorNode =
+        declaration.redirectedConstructor;
     if (redirectedConstructorNode == null) {
       return false;
     }
     // OK if no cycle
-    if (!_hasRedirectingFactoryConstructorCycle(constructorElement)) {
+    if (!_hasRedirectingFactoryConstructorCycle(element)) {
       return false;
     }
     // report error
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT,
         redirectedConstructorNode);
     return true;
   }
 
   /**
    * Check that the class [element] is not a superinterface to itself.
    *
    * See [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE],
    * [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS], and
    * [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS].
    */
-  bool _checkForRecursiveInterfaceInheritance(ClassElement classElt) {
-    if (classElt == null) {
+  bool _checkForRecursiveInterfaceInheritance(ClassElement element) {
+    if (element == null) {
       return false;
     }
     return _safeCheckForRecursiveInterfaceInheritance(
-        classElt, new List<ClassElement>());
+        element, new List<ClassElement>());
   }
 
   /**
    * Check that the given constructor [declaration] has a valid combination of
    * redirected constructor invocation(s), super constructor invocations and
    * field initializers.
    *
    * See [CompileTimeErrorCode.DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR],
    * [CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR],
    * [CompileTimeErrorCode.MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS],
    * [CompileTimeErrorCode.SUPER_IN_REDIRECTING_CONSTRUCTOR], and
    * [CompileTimeErrorCode.REDIRECT_GENERATIVE_TO_NON_GENERATIVE_CONSTRUCTOR].
    */
-  bool _checkForRedirectingConstructorErrorCodes(ConstructorDeclaration node) {
+  bool _checkForRedirectingConstructorErrorCodes(
+      ConstructorDeclaration declaration) {
     bool errorReported = false;
     //
     // Check for default values in the parameters
     //
-    ConstructorName redirectedConstructor = node.redirectedConstructor;
+    ConstructorName redirectedConstructor = declaration.redirectedConstructor;
     if (redirectedConstructor != null) {
-      for (FormalParameter parameter in node.parameters.parameters) {
+      for (FormalParameter parameter in declaration.parameters.parameters) {
         if (parameter is DefaultFormalParameter &&
             parameter.defaultValue != null) {
           _errorReporter.reportErrorForNode(
               CompileTimeErrorCode.DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR,
               parameter.identifier);
           errorReported = true;
         }
       }
     }
     // check if there are redirected invocations
     int numRedirections = 0;
-    for (ConstructorInitializer initializer in node.initializers) {
+    for (ConstructorInitializer initializer in declaration.initializers) {
       if (initializer is RedirectingConstructorInvocation) {
         if (numRedirections > 0) {
           _errorReporter.reportErrorForNode(
               CompileTimeErrorCode.MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS,
               initializer);
           errorReported = true;
         }
-        if (node.factoryKeyword == null) {
+        if (declaration.factoryKeyword == null) {
           RedirectingConstructorInvocation invocation = initializer;
           ConstructorElement redirectingElement = invocation.staticElement;
           if (redirectingElement == null) {
             String enclosingTypeName = _enclosingClass.displayName;
             String constructorStrName = enclosingTypeName;
             if (invocation.constructorName != null) {
               constructorStrName += ".${invocation.constructorName.name}";
             }
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.REDIRECT_GENERATIVE_TO_MISSING_CONSTRUCTOR,
                 invocation, [constructorStrName, enclosingTypeName]);
           } else {
             if (redirectingElement.isFactory) {
               _errorReporter.reportErrorForNode(
                   CompileTimeErrorCode.REDIRECT_GENERATIVE_TO_NON_GENERATIVE_CONSTRUCTOR,
                   initializer);
             }
           }
         }
         numRedirections++;
       }
     }
     // check for other initializers
     if (numRedirections > 0) {
-      for (ConstructorInitializer initializer in node.initializers) {
+      for (ConstructorInitializer initializer in declaration.initializers) {
         if (initializer is SuperConstructorInvocation) {
           _errorReporter.reportErrorForNode(
               CompileTimeErrorCode.SUPER_IN_REDIRECTING_CONSTRUCTOR,
               initializer);
           errorReported = true;
         }
         if (initializer is ConstructorFieldInitializer) {
           _errorReporter.reportErrorForNode(
               CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR,
               initializer);
           errorReported = true;
         }
       }
     }
     // done
     return errorReported;
   }
 
   /**
    * Check whether the given constructor [declaration] has redirected
    * constructor and references itself directly or indirectly. The
-   * [constructorElement] is the constructor element.
+   * constructor [element] is the element introduced by the declaration.
    *
    * See [CompileTimeErrorCode.REDIRECT_TO_NON_CONST_CONSTRUCTOR].
    */
   bool _checkForRedirectToNonConstConstructor(
-      ConstructorDeclaration node, ConstructorElement constructorElement) {
+      ConstructorDeclaration declaration, ConstructorElement element) {
     // prepare redirected constructor
-    ConstructorName redirectedConstructorNode = node.redirectedConstructor;
+    ConstructorName redirectedConstructorNode =
+        declaration.redirectedConstructor;
     if (redirectedConstructorNode == null) {
       return false;
     }
     // prepare element
-    if (constructorElement == null) {
+    if (element == null) {
       return false;
     }
     // OK, it is not 'const'
-    if (!constructorElement.isConst) {
+    if (!element.isConst) {
       return false;
     }
     // prepare redirected constructor
-    ConstructorElement redirectedConstructor =
-        constructorElement.redirectedConstructor;
+    ConstructorElement redirectedConstructor = element.redirectedConstructor;
     if (redirectedConstructor == null) {
       return false;
     }
     // OK, it is also 'const'
     if (redirectedConstructor.isConst) {
       return false;
     }
     // report error
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.REDIRECT_TO_NON_CONST_CONSTRUCTOR,
         redirectedConstructorNode);
     return true;
   }
 
   /**
    * Check that the given rethrow [expression] is inside of a catch clause.
    *
    * See [CompileTimeErrorCode.RETHROW_OUTSIDE_CATCH].
    */
-  bool _checkForRethrowOutsideCatch(RethrowExpression node) {
+  bool _checkForRethrowOutsideCatch(RethrowExpression expression) {
     if (!_isInCatchClause) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.RETHROW_OUTSIDE_CATCH, node);
+          CompileTimeErrorCode.RETHROW_OUTSIDE_CATCH, expression);
       return true;
     }
     return false;
   }
 
   /**
    * Check that if the the given constructor [declaration] is generative, then
    * it does not have an expression function body.
    *
    * See [CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR].
    */
-  bool _checkForReturnInGenerativeConstructor(ConstructorDeclaration node) {
+  bool _checkForReturnInGenerativeConstructor(
+      ConstructorDeclaration declaration) {
     // ignore factory
-    if (node.factoryKeyword != null) {
+    if (declaration.factoryKeyword != null) {
       return false;
     }
     // block body (with possible return statement) is checked elsewhere
-    FunctionBody body = node.body;
+    FunctionBody body = declaration.body;
     if (body is! ExpressionFunctionBody) {
       return false;
     }
     // report error
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR, body);
     return true;
   }
 
   /**
@@ skipping 84 matching lines @@
         StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER, name, [name.name]);
     return true;
   }
 
   /**
    * Check that the type of the expression in the given 'switch' [statement] is
    * assignable to the type of the 'case' members.
    *
    * See [StaticWarningCode.SWITCH_EXPRESSION_NOT_ASSIGNABLE].
    */
-  bool _checkForSwitchExpressionNotAssignable(SwitchStatement node) {
+  bool _checkForSwitchExpressionNotAssignable(SwitchStatement statement) {
     // prepare 'switch' expression type
-    Expression expression = node.expression;
+    Expression expression = statement.expression;
     DartType expressionType = getStaticType(expression);
     if (expressionType == null) {
       return false;
     }
     // compare with type of the first 'case'
-    NodeList<SwitchMember> members = node.members;
+    NodeList<SwitchMember> members = statement.members;
     for (SwitchMember switchMember in members) {
       if (switchMember is! SwitchCase) {
         continue;
       }
       SwitchCase switchCase = switchMember as SwitchCase;
       // prepare 'case' type
       Expression caseExpression = switchCase.expression;
       DartType caseType = getStaticType(caseExpression);
       // check types
       if (expressionType.isAssignableTo(caseType)) {
@@ skipping 10 matching lines @@
     return false;
   }
 
   /**
    * Verify that the given function type [alias] does not reference itself
    * directly.
    *
    * See [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF].
    */
   bool _checkForTypeAliasCannotReferenceItself_function(
-      FunctionTypeAlias node) {
-    FunctionTypeAliasElement element = node.element;
+      FunctionTypeAlias alias) {
+    FunctionTypeAliasElement element = alias.element;
     if (!_hasTypedefSelfReference(element)) {
       return false;
     }
     _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, node);
+        CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, alias);
     return true;
   }
 
   /**
    * Verify that the given type [name] is not a deferred type.
    *
    * See [StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS].
    */
-  bool _checkForTypeAnnotationDeferredClass(TypeName node) {
-    if (node != null && node.isDeferred) {
+  bool _checkForTypeAnnotationDeferredClass(TypeName name) {
+    if (name != null && name.isDeferred) {
       _errorReporter.reportErrorForNode(
-          StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, node, [node.name]);
+          StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, name, [name.name]);
     }
     return false;
   }
 
   /**
-   * Verify that the type arguments in the given type [name] are all within
+   * Verify that the type arguments in the given [typeName] are all within
    * their bounds.
    *
    * See [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS].
    */
-  bool _checkForTypeArgumentNotMatchingBounds(TypeName node) {
-    if (node.typeArguments == null) {
+  bool _checkForTypeArgumentNotMatchingBounds(TypeName typeName) {
+    if (typeName.typeArguments == null) {
       return false;
     }
     // prepare Type
-    DartType type = node.type;
+    DartType type = typeName.type;
     if (type == null) {
       return false;
     }
     // prepare ClassElement
     Element element = type.element;
     if (element is! ClassElement) {
       return false;
     }
     ClassElement classElement = element as ClassElement;
     // prepare type parameters
     List<DartType> typeParameters = classElement.type.typeArguments;
     List<TypeParameterElement> boundingElts = classElement.typeParameters;
     // iterate over each bounded type parameter and corresponding argument
-    NodeList<TypeName> typeNameArgList = node.typeArguments.arguments;
+    NodeList<TypeName> typeNameArgList = typeName.typeArguments.arguments;
     List<DartType> typeArguments = (type as InterfaceType).typeArguments;
     int loopThroughIndex =
         math.min(typeNameArgList.length, boundingElts.length);
     bool foundError = false;
     for (int i = 0; i < loopThroughIndex; i++) {
       TypeName argTypeName = typeNameArgList[i];
       DartType argType = argTypeName.type;
       DartType boundType = boundingElts[i].bound;
       if (argType != null && boundType != null) {
         if (typeArguments.length != 0 &&
@@ skipping 15 matching lines @@
     }
     return foundError;
   }
 
   /**
    * Check whether the given type [name] is a type parameter being used to
    * define a static member.
    *
    * See [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC].
    */
-  bool _checkForTypeParameterReferencedByStatic(TypeName node) {
+  bool _checkForTypeParameterReferencedByStatic(TypeName name) {
     if (_isInStaticMethod || _isInStaticVariableDeclaration) {
-      DartType type = node.type;
+      DartType type = name.type;
       if (type is TypeParameterType) {
         _errorReporter.reportErrorForNode(
-            StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC, node);
+            StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC, name);
         return true;
       }
     }
     return false;
   }
 
   /**
    * Check whether the given type [parameter] is a supertype of its bound.
    *
    * See [StaticTypeWarningCode.TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND].
    */
-  bool _checkForTypeParameterSupertypeOfItsBound(TypeParameter node) {
-    TypeParameterElement element = node.element;
+  bool _checkForTypeParameterSupertypeOfItsBound(TypeParameter parameter) {
+    TypeParameterElement element = parameter.element;
     // prepare bound
     DartType bound = element.bound;
     if (bound == null) {
       return false;
     }
     // OK, type parameter is not supertype of its bound
     if (!bound.isMoreSpecificThan(element.type)) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        StaticTypeWarningCode.TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND, node,
+        StaticTypeWarningCode.TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND, parameter,
         [element.displayName]);
     return true;
   }
 
   /**
    * Check that if the given generative [constructor] has neither an explicit
    * super constructor invocation nor a redirecting constructor invocation, that
    * the superclass has a default generative constructor.
    *
    * See [CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT],
    * [CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR], and
    * [StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT].
    */
   bool _checkForUndefinedConstructorInInitializerImplicit(
-      ConstructorDeclaration node) {
+      ConstructorDeclaration constructor) {
     if (_enclosingClass == null) {
       return false;
     }
     // do nothing if mixin errors have already been reported for this class.
     ClassElementImpl enclosingClass = _enclosingClass;
     if (enclosingClass.mixinErrorsReported) {
       return false;
     }
     //
     // Ignore if the constructor is not generative.
     //
-    if (node.factoryKeyword != null) {
+    if (constructor.factoryKeyword != null) {
       return false;
     }
     //
     // Ignore if the constructor has either an implicit super constructor
     // invocation or a redirecting constructor invocation.
     //
-    for (ConstructorInitializer constructorInitializer in node.initializers) {
+    for (ConstructorInitializer constructorInitializer
+        in constructor.initializers) {
       if (constructorInitializer is SuperConstructorInvocation ||
           constructorInitializer is RedirectingConstructorInvocation) {
         return false;
       }
     }
     //
     // Check to see whether the superclass has a non-factory unnamed
     // constructor.
     //
     InterfaceType superType = _enclosingClass.supertype;
     if (superType == null) {
       return false;
     }
     ClassElement superElement = superType.element;
     ConstructorElement superUnnamedConstructor =
         superElement.unnamedConstructor;
     if (superUnnamedConstructor != null) {
       if (superUnnamedConstructor.isFactory) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node.returnType,
-            [superUnnamedConstructor]);
+            CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR,
+            constructor.returnType, [superUnnamedConstructor]);
         return true;
       }
       if (!superUnnamedConstructor.isDefaultConstructor ||
           !_enclosingClass
               .isSuperConstructorAccessible(superUnnamedConstructor)) {
         int offset;
         int length;
         {
-          Identifier returnType = node.returnType;
-          SimpleIdentifier name = node.name;
+          Identifier returnType = constructor.returnType;
+          SimpleIdentifier name = constructor.name;
           offset = returnType.offset;
           length = (name != null ? name.end : returnType.end) - offset;
         }
         _errorReporter.reportErrorForOffset(
             CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT, offset,
             length, [superType.displayName]);
       }
       return false;
     }
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT,
-        node.returnType, [superElement.name]);
+        constructor.returnType, [superElement.name]);
     return true;
   }
 
   /**
    * Check that if the given [name] is a reference to a static member it is
    * defined in the enclosing class rather than in a superclass.
    *
    * See [StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER].
    */
   bool _checkForUnqualifiedReferenceToNonLocalStaticMember(
@@ skipping 12 matching lines @@
     }
     if (identical(enclosingElement, _enclosingClass)) {
       return false;
     }
     _errorReporter.reportErrorForNode(
         StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER,
         name, [name.name]);
     return true;
   }
 
-  void _checkForValidField(FieldFormalParameter node) {
-    ParameterElement element = node.element;
+  void _checkForValidField(FieldFormalParameter parameter) {
+    ParameterElement element = parameter.element;
     if (element is FieldFormalParameterElement) {
       FieldElement fieldElement = element.field;
       if (fieldElement == null || fieldElement.isSynthetic) {
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD,
-            node, [node.identifier.name]);
+            parameter, [parameter.identifier.name]);
       } else {
-        ParameterElement parameterElement = node.element;
+        ParameterElement parameterElement = parameter.element;
         if (parameterElement is FieldFormalParameterElementImpl) {
           FieldFormalParameterElementImpl fieldFormal = parameterElement;
           DartType declaredType = fieldFormal.type;
           DartType fieldType = fieldElement.type;
           if (fieldElement.isSynthetic) {
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD,
-                node, [node.identifier.name]);
+                parameter, [parameter.identifier.name]);
           } else if (fieldElement.isStatic) {
             _errorReporter.reportErrorForNode(
-                CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node,
-                [node.identifier.name]);
+                CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD,
+                parameter, [parameter.identifier.name]);
           } else if (declaredType != null &&
               fieldType != null &&
               !declaredType.isAssignableTo(fieldType)) {
             _errorReporter.reportTypeErrorForNode(
                 StaticWarningCode.FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE,
-                node, [declaredType, fieldType]);
+                parameter, [declaredType, fieldType]);
           }
         } else {
           if (fieldElement.isSynthetic) {
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD,
-                node, [node.identifier.name]);
+                parameter, [parameter.identifier.name]);
           } else if (fieldElement.isStatic) {
             _errorReporter.reportErrorForNode(
-                CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node,
-                [node.identifier.name]);
+                CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD,
+                parameter, [parameter.identifier.name]);
           }
         }
       }
     }
 //        else {
 //        // TODO(jwren) Report error, constructor initializer variable is a top level element
 //        // (Either here or in ErrorVerifier.checkForAllFinalInitializedErrorCodes)
 //        }
   }
 
   /**
    * Verify that the given [getter] does not have a return type of 'void'.
    *
    * See [StaticWarningCode.VOID_RETURN_FOR_GETTER].
    */
-  bool _checkForVoidReturnType(MethodDeclaration node) {
-    TypeName returnType = node.returnType;
+  bool _checkForVoidReturnType(MethodDeclaration getter) {
+    TypeName returnType = getter.returnType;
     if (returnType == null || returnType.name.name != "void") {
       return false;
     }
     _errorReporter.reportErrorForNode(
         StaticWarningCode.VOID_RETURN_FOR_GETTER, returnType);
     return true;
   }
 
   /**
    * Verify the given operator-method [declaration], has correct number of
    * parameters.
    *
    * This method assumes that the method declaration was tested to be an
    * operator declaration before being called.
    *
    * See [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR].
    */
-  bool _checkForWrongNumberOfParametersForOperator(MethodDeclaration node) {
+  bool _checkForWrongNumberOfParametersForOperator(
+      MethodDeclaration declaration) {
     // prepare number of parameters
-    FormalParameterList parameterList = node.parameters;
+    FormalParameterList parameterList = declaration.parameters;
     if (parameterList == null) {
       return false;
     }
     int numParameters = parameterList.parameters.length;
     // prepare operator name
-    SimpleIdentifier nameNode = node.name;
+    SimpleIdentifier nameNode = declaration.name;
     if (nameNode == null) {
       return false;
     }
     String name = nameNode.name;
     // check for exact number of parameters
     int expected = -1;
     if ("[]=" == name) {
       expected = 2;
     } else if ("<" == name ||
         ">" == name ||
@@ skipping 114 matching lines @@
     }
     return false;
   }
 
   /**
    * Verify that if the given class [declaration] implements the class Function
    * that it has a concrete implementation of the call method.
    *
    * See [StaticWarningCode.FUNCTION_WITHOUT_CALL].
    */
-  bool _checkImplementsFunctionWithoutCall(ClassDeclaration node) {
-    if (node.isAbstract) {
+  bool _checkImplementsFunctionWithoutCall(ClassDeclaration declaration) {
+    if (declaration.isAbstract) {
       return false;
     }
-    ClassElement classElement = node.element;
+    ClassElement classElement = declaration.element;
     if (classElement == null) {
       return false;
     }
     if (!classElement.type.isSubtypeOf(_typeProvider.functionType)) {
       return false;
     }
     // If there is a noSuchMethod method, then don't report the warning,
     // see dartbug.com/16078
     if (classElement.getMethod(FunctionElement.NO_SUCH_METHOD_METHOD_NAME) !=
         null) {
       return false;
     }
     ExecutableElement callMethod = _inheritanceManager.lookupMember(
         classElement, FunctionElement.CALL_METHOD_NAME);
     if (callMethod == null ||
         callMethod is! MethodElement ||
         (callMethod as MethodElement).isAbstract) {
       _errorReporter.reportErrorForNode(
-          StaticWarningCode.FUNCTION_WITHOUT_CALL, node.name);
+          StaticWarningCode.FUNCTION_WITHOUT_CALL, declaration.name);
       return true;
     }
     return false;
   }
 
   /**
    * Verify that the given class [declaration] does not have the same class in
    * the 'extends' and 'implements' clauses.
    *
    * See [CompileTimeErrorCode.IMPLEMENTS_SUPER_CLASS].
    */
-  bool _checkImplementsSuperClass(ClassDeclaration node) {
+  bool _checkImplementsSuperClass(ClassDeclaration declaration) {
     // prepare super type
     InterfaceType superType = _enclosingClass.supertype;
     if (superType == null) {
       return false;
     }
     // prepare interfaces
-    ImplementsClause implementsClause = node.implementsClause;
+    ImplementsClause implementsClause = declaration.implementsClause;
     if (implementsClause == null) {
       return false;
     }
     // check interfaces
     bool hasProblem = false;
     for (TypeName interfaceNode in implementsClause.interfaces) {
       if (interfaceNode.type == superType) {
         hasProblem = true;
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.IMPLEMENTS_SUPER_CLASS, interfaceNode,
@@ skipping 21 matching lines @@
         StaticTypeAnalyzer.flattenFutures(_typeProvider, staticReturnType)
       ]);
     }
     return staticReturnType;
   }
 
   /**
    * Return the error code that should be used when the given class [element]
    * references itself directly.
    */
-  ErrorCode _getBaseCaseErrorCode(ClassElement classElt) {
-    InterfaceType supertype = classElt.supertype;
+  ErrorCode _getBaseCaseErrorCode(ClassElement element) {
+    InterfaceType supertype = element.supertype;
     if (supertype != null && _enclosingClass == supertype.element) {
       return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS;
     }
-    List<InterfaceType> mixins = classElt.mixins;
+    List<InterfaceType> mixins = element.mixins;
     for (int i = 0; i < mixins.length; i++) {
       if (_enclosingClass == mixins[i].element) {
         return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH;
       }
     }
     return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS;
   }
 
   /**
    * Given an [expression] in a switch case whose value is expected to be an
    * enum constant, return the name of the constant.
    */
   String _getConstantName(Expression expression) {
     // TODO(brianwilkerson) Convert this to return the element representing the
     // constant.
     if (expression is SimpleIdentifier) {
       return expression.name;
     } else if (expression is PrefixedIdentifier) {
       return expression.identifier.name;
     } else if (expression is PropertyAccess) {
       return expression.propertyName.name;
     }
     return null;
   }
 
   /**
    * Return the return type of the given [getter].
    */
-  DartType _getGetterType(PropertyAccessorElement propertyAccessorElement) {
-    FunctionType functionType = propertyAccessorElement.type;
+  DartType _getGetterType(PropertyAccessorElement getter) {
+    FunctionType functionType = getter.type;
     if (functionType != null) {
       return functionType.returnType;
     } else {
       return null;
     }
   }
 
   /**
    * Return the type of the first and only parameter of the given [setter].
    */
-  DartType _getSetterType(PropertyAccessorElement propertyAccessorElement) {
+  DartType _getSetterType(PropertyAccessorElement setter) {
     // Get the parameters for MethodDeclaration or FunctionDeclaration
-    List<ParameterElement> setterParameters =
-        propertyAccessorElement.parameters;
+    List<ParameterElement> setterParameters = setter.parameters;
     // If there are no setter parameters, return no type.
     if (setterParameters.length == 0) {
       return null;
     }
     return setterParameters[0].type;
   }
 
   /**
    * Given a list of [directives] that have the same prefix, generate an error
    * if there is more than one import and any of those imports is deferred.
@@ skipping 13 matching lines @@
         }
       }
     }
     return foundError;
   }
 
   /**
    * Return `true` if the given [constructor] redirects to itself, directly or
    * indirectly.
    */
-  bool _hasRedirectingFactoryConstructorCycle(ConstructorElement element) {
+  bool _hasRedirectingFactoryConstructorCycle(ConstructorElement constructor) {
     Set<ConstructorElement> constructors = new HashSet<ConstructorElement>();
-    ConstructorElement current = element;
+    ConstructorElement current = constructor;
     while (current != null) {
       if (constructors.contains(current)) {
-        return identical(current, element);
+        return identical(current, constructor);
       }
       constructors.add(current);
       current = current.redirectedConstructor;
       if (current is ConstructorMember) {
         current = (current as ConstructorMember).baseElement;
       }
     }
     return false;
   }
 
   /**
    * Return `true` if the given [element] has direct or indirect reference to
    * itself from anywhere except a class element or type parameter bounds.
    */
-  bool _hasTypedefSelfReference(Element target) {
+  bool _hasTypedefSelfReference(Element element) {
     Set<Element> checked = new HashSet<Element>();
     List<Element> toCheck = new List<Element>();
     GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference elementVisitor =
         new GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference(
             toCheck);
-    toCheck.add(target);
+    toCheck.add(element);
     bool firstIteration = true;
     while (true) {
       Element current;
       // get next element
       while (true) {
         // may be no more elements to check
         if (toCheck.isEmpty) {
           return false;
         }
         // try to get next element
         current = toCheck.removeAt(toCheck.length - 1);
-        if (target == current) {
+        if (element == current) {
           if (firstIteration) {
             firstIteration = false;
             break;
           } else {
             return true;
           }
         }
         if (current != null && !checked.contains(current)) {
           break;
         }
@@ skipping 11 matching lines @@
       return true;
     } else if (type is InterfaceType) {
       MethodElement callMethod =
           type.lookUpMethod(FunctionElement.CALL_METHOD_NAME, _currentLibrary);
       return callMethod != null;
     }
     return false;
   }
 
   /**
-   * Return `true` iff the given class [element] has a method, getter or setter
-   * that matches the name of the given executable [element] in either the class
-   * itself, or one of its' mixins that is concrete.
+   * Return `true` iff the given [classElement] has a concrete method, getter or
+   * setter that matches the name of the given [executableElement] in either the
+   * class itself, or one of its' mixins.
    *
    * By "match", only the name of the member is tested to match, it does not
    * have to equal or be a subtype of the given executable element, this is due
    * to the specific use where this method is used in
    * [_checkForNonAbstractClassInheritsAbstractMember].
    */
   bool _isMemberInClassOrMixin(
-      ExecutableElement executableElt, ClassElement classElt) {
+      ExecutableElement executableElement, ClassElement classElement) {
     ExecutableElement foundElt = null;
-    String executableName = executableElt.name;
-    if (executableElt is MethodElement) {
-      foundElt = classElt.getMethod(executableName);
+    String executableName = executableElement.name;
+    if (executableElement is MethodElement) {
+      foundElt = classElement.getMethod(executableName);
       if (foundElt != null && !(foundElt as MethodElement).isAbstract) {
         return true;
       }
-      List<InterfaceType> mixins = classElt.mixins;
+      List<InterfaceType> mixins = classElement.mixins;
       for (int i = 0; i < mixins.length && foundElt == null; i++) {
         foundElt = mixins[i].getMethod(executableName);
       }
       if (foundElt != null && !(foundElt as MethodElement).isAbstract) {
         return true;
       }
-    } else if (executableElt is PropertyAccessorElement) {
-      PropertyAccessorElement propertyAccessorElement = executableElt;
+    } else if (executableElement is PropertyAccessorElement) {
+      PropertyAccessorElement propertyAccessorElement = executableElement;
       if (propertyAccessorElement.isGetter) {
-        foundElt = classElt.getGetter(executableName);
+        foundElt = classElement.getGetter(executableName);
       }
       if (foundElt == null && propertyAccessorElement.isSetter) {
-        foundElt = classElt.getSetter(executableName);
+        foundElt = classElement.getSetter(executableName);
       }
       if (foundElt != null &&
           !(foundElt as PropertyAccessorElement).isAbstract) {
         return true;
       }
-      List<InterfaceType> mixins = classElt.mixins;
+      List<InterfaceType> mixins = classElement.mixins;
       for (int i = 0; i < mixins.length && foundElt == null; i++) {
         foundElt = mixins[i].getGetter(executableName);
         if (foundElt == null) {
           foundElt = mixins[i].getSetter(executableName);
         }
       }
       if (foundElt != null &&
           !(foundElt as PropertyAccessorElement).isAbstract) {
         return true;
       }
     }
     return false;
   }
 
   /**
    * Return `true` if the given 'this' [expression] is in a valid context.
    */
-  bool _isThisInValidContext(ThisExpression node) {
-    for (AstNode n = node; n != null; n = n.parent) {
-      if (n is CompilationUnit) {
+  bool _isThisInValidContext(ThisExpression expression) {
+    for (AstNode node = expression.parent; node != null; node = node.parent) {
+      if (node is CompilationUnit) {
         return false;
       }
-      if (n is ConstructorDeclaration) {
-        return n.factoryKeyword == null;
+      if (node is ConstructorDeclaration) {
+        return node.factoryKeyword == null;
       }
-      if (n is ConstructorInitializer) {
+      if (node is ConstructorInitializer) {
         return false;
       }
-      if (n is MethodDeclaration) {
-        return !n.isStatic;
+      if (node is MethodDeclaration) {
+        return !node.isStatic;
       }
     }
     return false;
   }
 
   /**
    * Return `true` if the given [identifier] is in a location where it is
    * allowed to resolve to a static member of a supertype.
    */
   bool _isUnqualifiedReferenceToNonLocalStaticMemberAllowed(
-      SimpleIdentifier node) {
-    if (node.inDeclarationContext()) {
+      SimpleIdentifier identifier) {
+    if (identifier.inDeclarationContext()) {
       return true;
     }
-    AstNode parent = node.parent;
+    AstNode parent = identifier.parent;
     if (parent is ConstructorName ||
         parent is MethodInvocation ||
         parent is PropertyAccess ||
         parent is SuperConstructorInvocation) {
       return true;
     }
-    if (parent is PrefixedIdentifier && identical(parent.identifier, node)) {
+    if (parent is PrefixedIdentifier &&
+        identical(parent.identifier, identifier)) {
       return true;
     }
-    if (parent is Annotation && identical(parent.constructorName, node)) {
+    if (parent is Annotation && identical(parent.constructorName, identifier)) {
       return true;
     }
     if (parent is CommentReference) {
       CommentReference commentReference = parent;
       if (commentReference.newKeyword != null) {
         return true;
       }
     }
     return false;
   }
 
   bool _isUserDefinedObject(EvaluationResultImpl result) => result == null ||
       (result.value != null && result.value.isUserDefinedObject);
 
   /**
    * Check that the given class [element] is not a superinterface to itself. The
    * [path] is a list containing the potentially cyclic implements path.
    *
    * See [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE],
    * [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS],
    * [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS],
    * and [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH].
    */
   bool _safeCheckForRecursiveInterfaceInheritance(
-      ClassElement classElt, List<ClassElement> path) {
+      ClassElement element, List<ClassElement> path) {
     // Detect error condition.
     int size = path.length;
     // If this is not the base case (size > 0), and the enclosing class is the
     // given class element then an error an error.
-    if (size > 0 && _enclosingClass == classElt) {
+    if (size > 0 && _enclosingClass == element) {
       String enclosingClassName = _enclosingClass.displayName;
       if (size > 1) {
         // Construct a string showing the cyclic implements path:
         // "A, B, C, D, A"
         String separator = ", ";
         StringBuffer buffer = new StringBuffer();
         for (int i = 0; i < size; i++) {
           buffer.write(path[i].displayName);
           buffer.write(separator);
         }
-        buffer.write(classElt.displayName);
+        buffer.write(element.displayName);
         _errorReporter.reportErrorForOffset(
             CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
             _enclosingClass.nameOffset, enclosingClassName.length, [
           enclosingClassName,
           buffer.toString()
         ]);
         return true;
       } else {
         // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS or
         // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS or
         // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH
-        _errorReporter.reportErrorForOffset(_getBaseCaseErrorCode(classElt),
+        _errorReporter.reportErrorForOffset(_getBaseCaseErrorCode(element),
             _enclosingClass.nameOffset, enclosingClassName.length,
             [enclosingClassName]);
         return true;
       }
     }
-    if (path.indexOf(classElt) > 0) {
+    if (path.indexOf(element) > 0) {
       return false;
     }
-    path.add(classElt);
+    path.add(element);
     // n-case
-    InterfaceType supertype = classElt.supertype;
+    InterfaceType supertype = element.supertype;
     if (supertype != null &&
         _safeCheckForRecursiveInterfaceInheritance(supertype.element, path)) {
       return true;
     }
-    List<InterfaceType> interfaceTypes = classElt.interfaces;
+    List<InterfaceType> interfaceTypes = element.interfaces;
     for (InterfaceType interfaceType in interfaceTypes) {
       if (_safeCheckForRecursiveInterfaceInheritance(
           interfaceType.element, path)) {
         return true;
       }
     }
-    List<InterfaceType> mixinTypes = classElt.mixins;
+    List<InterfaceType> mixinTypes = element.mixins;
     for (InterfaceType mixinType in mixinTypes) {
       if (_safeCheckForRecursiveInterfaceInheritance(mixinType.element, path)) {
         return true;
       }
     }
     path.removeAt(path.length - 1);
     return false;
   }
 
   /**
@@ skipping 63 matching lines @@
     toCheck.add(type.element);
     // type arguments
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       for (DartType typeArgument in interfaceType.typeArguments) {
         _addTypeToCheck(typeArgument);
       }
     }
   }
 }