Remove unnecessary casts and general code clean-up

pkg/analyzer/lib/src/generated/resolver.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 analyzer.src.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 503 matching lines @@
    * @param element some element to check for deprecated use of
    * @param node the node use for the location of the error
    * @return `true` if and only if a hint code is generated on the passed node
    * See [HintCode.DEPRECATED_MEMBER_USE].
    */
   void _checkForDeprecatedMemberUse(Element element, AstNode node) {
     bool isDeprecated(Element element) {
       if (element == null) {
         return false;
       } else if (element is PropertyAccessorElement && element.isSynthetic) {
-        element = (element as PropertyAccessorElement).variable;
-        if (element == null) {
+        // TODO(brianwilkerson) Why isn't this the implementation for PropertyAccessorElement?
+        Element variable = element.variable;
+        if (variable == null) {
           return false;
         }
+        return variable.isDeprecated;
       }
       return element.isDeprecated;
     }
     if (!inDeprecatedMember && isDeprecated(element)) {
       String displayName = element.displayName;
       if (element is ConstructorElement) {
         // TODO(jwren) We should modify ConstructorElement.getDisplayName(),
         // or have the logic centralized elsewhere, instead of doing this logic
         // here.
-        ConstructorElement constructorElement = element;
-        displayName = constructorElement.enclosingElement.displayName;
-        if (!constructorElement.displayName.isEmpty) {
-          displayName = "$displayName.${constructorElement.displayName}";
+        displayName = element.enclosingElement.displayName;
+        if (!element.displayName.isEmpty) {
+          displayName = "$displayName.${element.displayName}";
         }
       }
       _errorReporter.reportErrorForNode(
           HintCode.DEPRECATED_MEMBER_USE, node, [displayName]);
     }
   }
 
   /**
    * For [SimpleIdentifier]s, only call [checkForDeprecatedMemberUse]
    * if the node is not in a declaration context.
@@ skipping 40 matching lines @@
     // its static or propagated type
     MethodElement methodElement = node.bestElement;
     if (methodElement == null) {
       return false;
     }
     LibraryElement libraryElement = methodElement.library;
     if (libraryElement != null && !libraryElement.isDartCore) {
       return false;
     }
     // Report error if the (x/y) has toInt() invoked on it
-    if (node.parent is ParenthesizedExpression) {
+    AstNode parent = node.parent;
+    if (parent is ParenthesizedExpression) {
       ParenthesizedExpression parenthesizedExpression =
-          _wrapParenthesizedExpression(node.parent as ParenthesizedExpression);
-      if (parenthesizedExpression.parent is MethodInvocation) {
-        MethodInvocation methodInvocation =
-            parenthesizedExpression.parent as MethodInvocation;
-        if (_TO_INT_METHOD_NAME == methodInvocation.methodName.name &&
-            methodInvocation.argumentList.arguments.isEmpty) {
+          _wrapParenthesizedExpression(parent);
+      AstNode grandParent = parenthesizedExpression.parent;
+      if (grandParent is MethodInvocation) {
+        if (_TO_INT_METHOD_NAME == grandParent.methodName.name &&
+            grandParent.argumentList.arguments.isEmpty) {
           _errorReporter.reportErrorForNode(
-              HintCode.DIVISION_OPTIMIZATION, methodInvocation);
+              HintCode.DIVISION_OPTIMIZATION, grandParent);
           return true;
         }
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed left hand side and right hand side represent a valid assignment.
    *
@@ skipping 401 matching lines @@
    * expression.
    *
    * For example given the code `(((e)))`: `(e) -> (((e)))`.
    *
    * @param parenthesizedExpression some expression whose parent is a parenthesized expression
    * @return the first parent or grand-parent that is a parenthesized expression, that does not have
    *         a parenthesized expression parent
    */
   static ParenthesizedExpression _wrapParenthesizedExpression(
       ParenthesizedExpression parenthesizedExpression) {
-    if (parenthesizedExpression.parent is ParenthesizedExpression) {
-      return _wrapParenthesizedExpression(
-          parenthesizedExpression.parent as ParenthesizedExpression);
+    AstNode parent = parenthesizedExpression.parent;
+    if (parent is ParenthesizedExpression) {
+      return _wrapParenthesizedExpression(parent);
     }
     return parenthesizedExpression;
   }
 }
 
 /**
  * Utilities for [LibraryElementImpl] building.
  */
 class BuildLibraryElementUtils {
   /**
@@ skipping 114 matching lines @@
     this._numType = _typeProvider.numType;
     this._stringType = _typeProvider.stringType;
   }
 
   @override
   Object visitAnnotation(Annotation node) {
     super.visitAnnotation(node);
     // check annotation creation
     Element element = node.element;
     if (element is ConstructorElement) {
-      ConstructorElement constructorElement = element;
-      // should 'const' constructor
-      if (!constructorElement.isConst) {
+      // should be 'const' constructor
+      if (!element.isConst) {
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.NON_CONSTANT_ANNOTATION_CONSTRUCTOR, node);
         return null;
       }
       // should have arguments
       ArgumentList argumentList = node.arguments;
       if (argumentList == null) {
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.NO_ANNOTATION_CONSTRUCTOR_ARGUMENTS, node);
         return null;
@@ skipping 142 matching lines @@
   @override
   Object visitSwitchStatement(SwitchStatement node) {
     // TODO(paulberry): to minimize error messages, it would be nice to
     // compare all types with the most popular type rather than the first
     // type.
     NodeList<SwitchMember> switchMembers = node.members;
     bool foundError = false;
     DartType firstType = null;
     for (SwitchMember switchMember in switchMembers) {
       if (switchMember is SwitchCase) {
-        SwitchCase switchCase = switchMember;
-        Expression expression = switchCase.expression;
+        Expression expression = switchMember.expression;
         DartObjectImpl caseResult = _validate(
             expression, CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION);
         if (caseResult != null) {
           _reportErrorIfFromDeferredLibrary(
               expression,
               CompileTimeErrorCode
                   .NON_CONSTANT_CASE_EXPRESSION_FROM_DEFERRED_LIBRARY);
           DartObject value = caseResult;
           if (firstType == null) {
             firstType = value.type;
@@ skipping 167 matching lines @@
     return result;
   }
 
   /**
    * Validate that if the passed arguments are constant expressions.
    *
    * @param argumentList the argument list to evaluate
    */
   void _validateConstantArguments(ArgumentList argumentList) {
     for (Expression argument in argumentList.arguments) {
-      if (argument is NamedExpression) {
-        argument = (argument as NamedExpression).expression;
-      }
+      Expression realArgument =
+          argument is NamedExpression ? argument.expression : argument;
       _validate(
-          argument, CompileTimeErrorCode.CONST_WITH_NON_CONSTANT_ARGUMENT);
+          realArgument, CompileTimeErrorCode.CONST_WITH_NON_CONSTANT_ARGUMENT);
     }
   }
 
   /**
    * Validates that the expressions of the given initializers (of a constant constructor) are all
    * compile time constants.
    *
    * @param constructor the constant constructor declaration to validate
    */
   void _validateConstructorInitializers(ConstructorDeclaration constructor) {
     List<ParameterElement> parameterElements =
         constructor.parameters.parameterElements;
     NodeList<ConstructorInitializer> initializers = constructor.initializers;
     for (ConstructorInitializer initializer in initializers) {
       if (initializer is ConstructorFieldInitializer) {
-        ConstructorFieldInitializer fieldInitializer = initializer;
         _validateInitializerExpression(
-            parameterElements, fieldInitializer.expression);
+            parameterElements, initializer.expression);
       }
       if (initializer is RedirectingConstructorInvocation) {
-        RedirectingConstructorInvocation invocation = initializer;
         _validateInitializerInvocationArguments(
-            parameterElements, invocation.argumentList);
+            parameterElements, initializer.argumentList);
       }
       if (initializer is SuperConstructorInvocation) {
-        SuperConstructorInvocation invocation = initializer;
         _validateInitializerInvocationArguments(
-            parameterElements, invocation.argumentList);
+            parameterElements, initializer.argumentList);
       }
     }
   }
 
   /**
    * Validate that the default value associated with each of the parameters in the given list is a
    * compile time constant.
    *
    * @param parameters the list of parameters to be validated
    */
   void _validateDefaultValues(FormalParameterList parameters) {
     if (parameters == null) {
       return;
     }
     for (FormalParameter parameter in parameters.parameters) {
       if (parameter is DefaultFormalParameter) {
-        DefaultFormalParameter defaultParameter = parameter;
-        Expression defaultValue = defaultParameter.defaultValue;
+        Expression defaultValue = parameter.defaultValue;
         DartObjectImpl result;
         if (defaultValue == null) {
           result =
               new DartObjectImpl(_typeProvider.nullType, NullState.NULL_STATE);
         } else {
           result = _validate(
               defaultValue, CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE);
           if (result != null) {
             _reportErrorIfFromDeferredLibrary(
                 defaultValue,
@@ skipping 12 matching lines @@
    * compile time constants. Since this is only required if the class has a constant constructor,
    * the error is reported at the constructor site.
    *
    * @param classDeclaration the class which should be validated
    * @param errorSite the site at which errors should be reported.
    */
   void _validateFieldInitializers(
       ClassDeclaration classDeclaration, ConstructorDeclaration errorSite) {
     NodeList<ClassMember> members = classDeclaration.members;
     for (ClassMember member in members) {
-      if (member is FieldDeclaration) {
-        FieldDeclaration fieldDeclaration = member;
-        if (!fieldDeclaration.isStatic) {
-          for (VariableDeclaration variableDeclaration
-              in fieldDeclaration.fields.variables) {
-            Expression initializer = variableDeclaration.initializer;
-            if (initializer != null) {
-              // Ignore any errors produced during validation--if the constant
-              // can't be eavluated we'll just report a single error.
-              AnalysisErrorListener errorListener =
-                  AnalysisErrorListener.NULL_LISTENER;
-              ErrorReporter subErrorReporter =
-                  new ErrorReporter(errorListener, _errorReporter.source);
-              DartObjectImpl result = initializer.accept(new ConstantVisitor(
-                  new ConstantEvaluationEngine(_typeProvider, declaredVariables,
-                      typeSystem: _typeSystem),
-                  subErrorReporter));
-              if (result == null) {
-                _errorReporter.reportErrorForNode(
-                    CompileTimeErrorCode
-                        .CONST_CONSTRUCTOR_WITH_FIELD_INITIALIZED_BY_NON_CONST,
-                    errorSite,
-                    [variableDeclaration.name.name]);
-              }
+      if (member is FieldDeclaration && !member.isStatic) {
+        for (VariableDeclaration variableDeclaration
+            in member.fields.variables) {
+          Expression initializer = variableDeclaration.initializer;
+          if (initializer != null) {
+            // Ignore any errors produced during validation--if the constant
+            // can't be eavluated we'll just report a single error.
+            AnalysisErrorListener errorListener =
+                AnalysisErrorListener.NULL_LISTENER;
+            ErrorReporter subErrorReporter =
+                new ErrorReporter(errorListener, _errorReporter.source);
+            DartObjectImpl result = initializer.accept(new ConstantVisitor(
+                new ConstantEvaluationEngine(_typeProvider, declaredVariables,
+                    typeSystem: _typeSystem),
+                subErrorReporter));
+            if (result == null) {
+              _errorReporter.reportErrorForNode(
+                  CompileTimeErrorCode
+                      .CONST_CONSTRUCTOR_WITH_FIELD_INITIALIZED_BY_NON_CONST,
+                  errorSite,
+                  [variableDeclaration.name.name]);
             }
           }
         }
       }
     }
   }
 
   /**
    * Validates that the given expression is a compile time constant.
    *
@@ skipping 489 matching lines @@
 
   /**
    * Return `true` if and only if the passed expression is resolved to a constant variable.
    *
    * @param expression some conditional expression
    * @return `true` if and only if the passed expression is resolved to a constant variable
    */
   bool _isDebugConstant(Expression expression) {
     Element element = null;
     if (expression is Identifier) {
-      Identifier identifier = expression;
-      element = identifier.staticElement;
+      element = expression.staticElement;
     } else if (expression is PropertyAccess) {
-      PropertyAccess propertyAccess = expression;
-      element = propertyAccess.propertyName.staticElement;
+      element = expression.propertyName.staticElement;
     }
     if (element is PropertyAccessorElement) {
       PropertyInducingElement variable = element.variable;
       return variable != null && variable.isConst;
     }
     return false;
   }
 }
 
 /**
@@ skipping 1330 matching lines @@
     Expression lhsExpression = node.leftOperand;
     Expression rhsExpression = node.rightOperand;
     TokenType operatorType = node.operator.type;
     // If the operator is ||, then only consider the RHS of the binary
     // expression if the left hand side is the false literal.
     // TODO(jwren) Do we want to take constant expressions into account,
     // evaluate if(false) {} differently than if(<condition>), when <condition>
     // evaluates to a constant false value?
     if (operatorType == TokenType.BAR_BAR) {
       if (lhsExpression is BooleanLiteral) {
-        BooleanLiteral booleanLiteral = lhsExpression;
-        if (!booleanLiteral.value) {
+        if (!lhsExpression.value) {
           return _nodeExits(rhsExpression);
         }
       }
       return _nodeExits(lhsExpression);
     }
     // If the operator is &&, then only consider the RHS of the binary
     // expression if the left hand side is the true literal.
     if (operatorType == TokenType.AMPERSAND_AMPERSAND) {
       if (lhsExpression is BooleanLiteral) {
-        BooleanLiteral booleanLiteral = lhsExpression;
-        if (booleanLiteral.value) {
+        if (lhsExpression.value) {
           return _nodeExits(rhsExpression);
         }
       }
       return _nodeExits(lhsExpression);
     }
     // If the operator is ??, then don't consider the RHS of the binary
     // expression.
     if (operatorType == TokenType.QUESTION_QUESTION) {
       return _nodeExits(lhsExpression);
     }
@@ skipping 40 matching lines @@
   bool visitDoStatement(DoStatement node) {
     bool outerBreakValue = _enclosingBlockContainsBreak;
     _enclosingBlockContainsBreak = false;
     try {
       Expression conditionExpression = node.condition;
       if (_nodeExits(conditionExpression)) {
         return true;
       }
       // TODO(jwren) Do we want to take all constant expressions into account?
       if (conditionExpression is BooleanLiteral) {
-        BooleanLiteral booleanLiteral = conditionExpression;
         // If do {} while (true), and the body doesn't return or the body
         // doesn't have a break, then return true.
         bool blockReturns = _nodeExits(node.body);
-        if (booleanLiteral.value &&
+        if (conditionExpression.value &&
             (blockReturns || !_enclosingBlockContainsBreak)) {
           return true;
         }
       }
       return false;
     } finally {
       _enclosingBlockContainsBreak = outerBreakValue;
     }
   }
 
@@ skipping 72 matching lines @@
   @override
   bool visitIfStatement(IfStatement node) {
     Expression conditionExpression = node.condition;
     Statement thenStatement = node.thenStatement;
     Statement elseStatement = node.elseStatement;
     if (_nodeExits(conditionExpression)) {
       return true;
     }
     // TODO(jwren) Do we want to take all constant expressions into account?
     if (conditionExpression is BooleanLiteral) {
-      BooleanLiteral booleanLiteral = conditionExpression;
-      if (booleanLiteral.value) {
+      if (conditionExpression.value) {
         // if(true) ...
         return _nodeExits(thenStatement);
       } else if (elseStatement != null) {
         // if (false) ...
         return _nodeExits(elseStatement);
       }
     }
     if (thenStatement == null || elseStatement == null) {
       return false;
     }
@@ skipping 173 matching lines @@
   bool visitWhileStatement(WhileStatement node) {
     bool outerBreakValue = _enclosingBlockContainsBreak;
     _enclosingBlockContainsBreak = false;
     try {
       Expression conditionExpression = node.condition;
       if (conditionExpression.accept(this)) {
         return true;
       }
       // TODO(jwren) Do we want to take all constant expressions into account?
       if (conditionExpression is BooleanLiteral) {
-        BooleanLiteral booleanLiteral = conditionExpression;
         // If while(true), and the body doesn't return or the body doesn't have
         // a break, then return true.
         bool blockReturns = node.body.accept(this);
-        if (booleanLiteral.value &&
+        if (conditionExpression.value &&
             (blockReturns || !_enclosingBlockContainsBreak)) {
           return true;
         }
       }
       return false;
     } finally {
       _enclosingBlockContainsBreak = outerBreakValue;
     }
   }
 
@@ skipping 107 matching lines @@
     directive.metadata.accept(this);
   }
 
   void _visitIdentifier(SimpleIdentifier identifier, Element element) {
     if (element == null) {
       return;
     }
     // If the element is multiply defined then call this method recursively for
     // each of the conflicting elements.
     if (element is MultiplyDefinedElement) {
-      MultiplyDefinedElement multiplyDefinedElement = element;
-      for (Element elt in multiplyDefinedElement.conflictingElements) {
+      for (Element elt in element.conflictingElements) {
         _visitIdentifier(identifier, elt);
       }
       return;
     }
 
     // Record `importPrefix.identifier` into 'prefixMap'.
     if (_recordPrefixMap(identifier, element)) {
       return;
     }
 
@@ skipping 336 matching lines @@
    * unused shown elements.
    *
    * See [ImportsVerifier.generateUnusedShownNameHints].
    */
   final HashMap<ImportDirective, List<SimpleIdentifier>> _unusedShownNamesMap =
       new HashMap<ImportDirective, List<SimpleIdentifier>>();
 
   void addImports(CompilationUnit node) {
     for (Directive directive in node.directives) {
       if (directive is ImportDirective) {
-        ImportDirective importDirective = directive;
-        LibraryElement libraryElement = importDirective.uriElement;
+        LibraryElement libraryElement = directive.uriElement;
         if (libraryElement == null) {
           continue;
         }
-        _unusedImports.add(importDirective);
+        _unusedImports.add(directive);
         //
         // Initialize prefixElementMap
         //
-        if (importDirective.asKeyword != null) {
-          SimpleIdentifier prefixIdentifier = importDirective.prefix;
+        if (directive.asKeyword != null) {
+          SimpleIdentifier prefixIdentifier = directive.prefix;
           if (prefixIdentifier != null) {
             Element element = prefixIdentifier.staticElement;
             if (element is PrefixElement) {
-              PrefixElement prefixElementKey = element;
-              List<ImportDirective> list = _prefixElementMap[prefixElementKey];
+              List<ImportDirective> list = _prefixElementMap[element];
               if (list == null) {
                 list = new List<ImportDirective>();
-                _prefixElementMap[prefixElementKey] = list;
+                _prefixElementMap[element] = list;
               }
-              list.add(importDirective);
+              list.add(directive);
             }
             // TODO (jwren) Can the element ever not be a PrefixElement?
           }
         }
         //
         // Initialize libraryMap: libraryElement -> importDirective
         //
-        _putIntoLibraryMap(libraryElement, importDirective);
+        _putIntoLibraryMap(libraryElement, directive);
         //
         // For this new addition to the libraryMap, also recursively add any
         // exports from the libraryElement.
         //
         _addAdditionalLibrariesForExports(
-            libraryElement, importDirective, new HashSet<LibraryElement>());
-        _addShownNames(importDirective);
+            libraryElement, directive, new HashSet<LibraryElement>());
+        _addShownNames(directive);
       }
     }
     if (_unusedImports.length > 1) {
       // order the list of unusedImports to find duplicates in faster than
       // O(n^2) time
       List<ImportDirective> importDirectiveArray =
           new List<ImportDirective>.from(_unusedImports);
       importDirectiveArray.sort(ImportDirective.COMPARATOR);
       ImportDirective currentDirective = importDirectiveArray[0];
       for (int i = 1; i < importDirectiveArray.length; i++) {
@@ skipping 2541 matching lines @@
   /**
    * The given expression is the expression used to compute the iterator for a
    * for-each statement. Attempt to compute the type of objects that will be
    * assigned to the loop variable and return that type. Return `null` if the
    * type could not be determined. The [iteratorExpression] is the expression
    * that will return the Iterable being iterated over.
    */
   DartType _getIteratorElementType(Expression iteratorExpression) {
     DartType expressionType = iteratorExpression.bestType;
     if (expressionType is InterfaceType) {
-      InterfaceType interfaceType = expressionType;
       PropertyAccessorElement iteratorFunction =
-          interfaceType.lookUpInheritedGetter("iterator");
+          expressionType.lookUpInheritedGetter("iterator");
       if (iteratorFunction == null) {
         // TODO(brianwilkerson) Should we report this error?
         return null;
       }
       DartType iteratorType = iteratorFunction.returnType;
       if (iteratorType is InterfaceType) {
-        InterfaceType iteratorInterfaceType = iteratorType;
         PropertyAccessorElement currentFunction =
-            iteratorInterfaceType.lookUpInheritedGetter("current");
+            iteratorType.lookUpInheritedGetter("current");
         if (currentFunction == null) {
           // TODO(brianwilkerson) Should we report this error?
           return null;
         }
         return currentFunction.returnType;
       }
     }
     return null;
   }
 
@@ skipping 243 matching lines @@
         _promoteManager.setType(element, potentialType);
       }
     }
   }
 
   /**
    * Promotes type information using given condition.
    */
   void _promoteTypes(Expression condition) {
     if (condition is BinaryExpression) {
-      BinaryExpression binary = condition;
-      if (binary.operator.type == TokenType.AMPERSAND_AMPERSAND) {
-        Expression left = binary.leftOperand;
-        Expression right = binary.rightOperand;
+      if (condition.operator.type == TokenType.AMPERSAND_AMPERSAND) {
+        Expression left = condition.leftOperand;
+        Expression right = condition.rightOperand;
         _promoteTypes(left);
         _promoteTypes(right);
         _clearTypePromotionsIfPotentiallyMutatedIn(right);
       }
     } else if (condition is IsExpression) {
-      IsExpression is2 = condition;
-      if (is2.notOperator == null) {
-        _promote(is2.expression, is2.type.type);
+      if (condition.notOperator == null) {
+        _promote(condition.expression, condition.type.type);
       }
     } else if (condition is ParenthesizedExpression) {
       _promoteTypes(condition.expression);
     }
   }
 
   /**
    * Propagate any type information that results from knowing that the given condition will have
    * been evaluated to 'false'.
    *
    * @param condition the condition that will have evaluated to 'false'
    */
   void _propagateFalseState(Expression condition) {
     if (condition is BinaryExpression) {
-      BinaryExpression binary = condition;
-      if (binary.operator.type == TokenType.BAR_BAR) {
-        _propagateFalseState(binary.leftOperand);
-        _propagateFalseState(binary.rightOperand);
+      if (condition.operator.type == TokenType.BAR_BAR) {
+        _propagateFalseState(condition.leftOperand);
+        _propagateFalseState(condition.rightOperand);
       }
     } else if (condition is IsExpression) {
-      IsExpression is2 = condition;
-      if (is2.notOperator != null) {
+      if (condition.notOperator != null) {
         // Since an is-statement doesn't actually change the type, we don't
         // let it affect the propagated type when it would result in a loss
         // of precision.
-        overrideExpression(is2.expression, is2.type.type, false, false);
+        overrideExpression(
+            condition.expression, condition.type.type, false, false);
       }
     } else if (condition is PrefixExpression) {
-      PrefixExpression prefix = condition;
-      if (prefix.operator.type == TokenType.BANG) {
-        _propagateTrueState(prefix.operand);
+      if (condition.operator.type == TokenType.BANG) {
+        _propagateTrueState(condition.operand);
       }
     } else if (condition is ParenthesizedExpression) {
       _propagateFalseState(condition.expression);
     }
   }
 
   /**
    * Propagate any type information that results from knowing that the given expression will have
    * been evaluated without altering the flow of execution.
    *
    * @param expression the expression that will have been evaluated
    */
   void _propagateState(Expression expression) {
     // TODO(brianwilkerson) Implement this.
   }
 
   /**
    * Propagate any type information that results from knowing that the given condition will have
    * been evaluated to 'true'.
    *
    * @param condition the condition that will have evaluated to 'true'
    */
   void _propagateTrueState(Expression condition) {
     if (condition is BinaryExpression) {
-      BinaryExpression binary = condition;
-      if (binary.operator.type == TokenType.AMPERSAND_AMPERSAND) {
-        _propagateTrueState(binary.leftOperand);
-        _propagateTrueState(binary.rightOperand);
+      if (condition.operator.type == TokenType.AMPERSAND_AMPERSAND) {
+        _propagateTrueState(condition.leftOperand);
+        _propagateTrueState(condition.rightOperand);
       }
     } else if (condition is IsExpression) {
-      IsExpression is2 = condition;
-      if (is2.notOperator == null) {
+      if (condition.notOperator == null) {
         // Since an is-statement doesn't actually change the type, we don't
         // let it affect the propagated type when it would result in a loss
         // of precision.
-        overrideExpression(is2.expression, is2.type.type, false, false);
+        overrideExpression(
+            condition.expression, condition.type.type, false, false);
       }
     } else if (condition is PrefixExpression) {
-      PrefixExpression prefix = condition;
-      if (prefix.operator.type == TokenType.BANG) {
-        _propagateFalseState(prefix.operand);
+      if (condition.operator.type == TokenType.BANG) {
+        _propagateFalseState(condition.operand);
       }
     } else if (condition is ParenthesizedExpression) {
       _propagateTrueState(condition.expression);
     }
   }
 
   /**
    * Given an [argumentList] and the [parameters] related to the element that
    * will be invoked using those arguments, compute the list of parameters that
    * correspond to the list of arguments.
@@ skipping 769 matching lines @@
    * Marks the local declarations of the given [Block] hidden in the enclosing scope.
    * According to the scoping rules name is hidden if block defines it, but name is defined after
    * its declaration statement.
    */
   void _hideNamesDefinedInBlock(EnclosedScope scope, Block block) {
     NodeList<Statement> statements = block.statements;
     int statementCount = statements.length;
     for (int i = 0; i < statementCount; i++) {
       Statement statement = statements[i];
       if (statement is VariableDeclarationStatement) {
-        VariableDeclarationStatement vds = statement;
-        NodeList<VariableDeclaration> variables = vds.variables.variables;
+        NodeList<VariableDeclaration> variables = statement.variables.variables;
         int variableCount = variables.length;
         for (int j = 0; j < variableCount; j++) {
           scope.hide(variables[j].element);
         }
       } else if (statement is FunctionDeclarationStatement) {
-        FunctionDeclarationStatement fds = statement;
-        scope.hide(fds.functionDeclaration.element);
+        scope.hide(statement.functionDeclaration.element);
       }
     }
   }
 }
 
 /**
  * Instances of this class manage the knowledge of what the set of subtypes are for a given type.
  */
 class SubtypeManager {
   /**
@@ skipping 406 matching lines @@
   }
 
   /**
    * Return the overridden type of the given element, or `null` if the type of the element
    * has not been overridden.
    *
    * @param element the element whose type might have been overridden
    * @return the overridden type of the given element
    */
   DartType getType(Element element) {
-    if (element is PropertyAccessorElement) {
-      element = (element as PropertyAccessorElement).variable;
-    }
-    DartType type = _overridenTypes[element];
-    if (_overridenTypes.containsKey(element)) {
+    Element nonAccessor =
+        element is PropertyAccessorElement ? element.variable : element;
+    DartType type = _overridenTypes[nonAccessor];
+    if (_overridenTypes.containsKey(nonAccessor)) {
       return type;
     }
     if (type != null) {
       return type;
     } else if (_outerScope != null) {
-      return _outerScope.getType(element);
+      return _outerScope.getType(nonAccessor);
     }
     return null;
   }
 
   /**
    * Clears the overridden type of the given [element].
    */
   void resetType(VariableElement element) {
     _overridenTypes[element] = null;
   }
@@ skipping 813 matching lines @@
     LocalVariableElementImpl element = node.element as LocalVariableElementImpl;
     element.type = declaredType;
     return null;
   }
 
   @override
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     super.visitFieldFormalParameter(node);
     Element element = node.identifier.staticElement;
     if (element is ParameterElementImpl) {
-      ParameterElementImpl parameter = element;
       FormalParameterList parameterList = node.parameters;
       if (parameterList == null) {
         DartType type;
         TypeName typeName = node.type;
         if (typeName == null) {
           element.hasImplicitType = true;
           type = _dynamicType;
-          if (parameter is FieldFormalParameterElement) {
+          if (element is FieldFormalParameterElement) {
             FieldElement fieldElement =
-                (parameter as FieldFormalParameterElement).field;
+                (element as FieldFormalParameterElement).field;
             if (fieldElement != null) {
               type = fieldElement.type;
             }
           }
         } else {
           type = _getType(typeName);
         }
-        parameter.type = type;
+        element.type = type;
       } else {
-        _setFunctionTypedParameterType(parameter, node.type, node.parameters);
+        _setFunctionTypedParameterType(element, node.type, node.parameters);
       }
     } else {
       // TODO(brianwilkerson) Report this internal error
     }
     return null;
   }
 
   @override
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     super.visitFunctionDeclaration(node);
@@ skipping 80 matching lines @@
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     super.visitSimpleFormalParameter(node);
     DartType declaredType;
     TypeName typeName = node.type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
       declaredType = _getType(typeName);
     }
     Element element = node.identifier.staticElement;
-    if (element is ParameterElement) {
-      (element as ParameterElementImpl).type = declaredType;
+    if (element is ParameterElementImpl) {
+      element.type = declaredType;
     } else {
       // TODO(brianwilkerson) Report the internal error.
     }
     return null;
   }
 
   @override
   Object visitSuperExpression(SuperExpression node) {
     _hasReferenceToSuper = true;
     return super.visitSuperExpression(node);
@@ skipping 272 matching lines @@
     TypeName typeName = (node.parent as VariableDeclarationList).type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
       declaredType = _getType(typeName);
     }
     Element element = node.name.staticElement;
     if (element is VariableElement) {
       (element as VariableElementImpl).type = declaredType;
       if (element is PropertyInducingElement) {
-        PropertyInducingElement variableElement = element;
         PropertyAccessorElementImpl getter =
-            variableElement.getter as PropertyAccessorElementImpl;
+            element.getter as PropertyAccessorElementImpl;
         getter.returnType = declaredType;
         getter.type = new FunctionTypeImpl(getter);
         PropertyAccessorElementImpl setter =
-            variableElement.setter as PropertyAccessorElementImpl;
+            element.setter as PropertyAccessorElementImpl;
         if (setter != null) {
           List<ParameterElement> parameters = setter.parameters;
           if (parameters.length > 0) {
             (parameters[0] as ParameterElementImpl).type = declaredType;
           }
           setter.returnType = VoidTypeImpl.instance;
           setter.type = new FunctionTypeImpl(setter);
         }
       }
     } else {
@@ skipping 88 matching lines @@
   /**
    * Checks if the given type name is the target in a redirected constructor.
    *
    * @param typeName the type name to analyze
    * @return some [RedirectingConstructorKind] if the given type name is used as the type in a
    *         redirected constructor, or `null` otherwise
    */
   RedirectingConstructorKind _getRedirectingConstructorKind(TypeName typeName) {
     AstNode parent = typeName.parent;
     if (parent is ConstructorName) {
-      ConstructorName constructorName = parent as ConstructorName;
-      parent = constructorName.parent;
-      if (parent is ConstructorDeclaration) {
-        if (identical(parent.redirectedConstructor, constructorName)) {
-          if (parent.constKeyword != null) {
+      AstNode grandParent = parent.parent;
+      if (grandParent is ConstructorDeclaration) {
+        if (identical(grandParent.redirectedConstructor, parent)) {
+          if (grandParent.constKeyword != null) {
             return RedirectingConstructorKind.CONST;
           }
           return RedirectingConstructorKind.NORMAL;
         }
       }
     }
     return null;
   }
 
   /**
@@ skipping 60 matching lines @@
 
   /**
    * Checks if the given type name is used as the type in an as expression.
    *
    * @param typeName the type name to analyzer
    * @return `true` if the given type name is used as the type in an as expression
    */
   bool _isTypeNameInAsExpression(TypeName typeName) {
     AstNode parent = typeName.parent;
     if (parent is AsExpression) {
-      AsExpression asExpression = parent;
-      return identical(asExpression.type, typeName);
+      return identical(parent.type, typeName);
     }
     return false;
   }
 
   /**
    * Checks if the given type name is used as the exception type in a catch clause.
    *
    * @param typeName the type name to analyzer
    * @return `true` if the given type name is used as the exception type in a catch clause
    */
   bool _isTypeNameInCatchClause(TypeName typeName) {
     AstNode parent = typeName.parent;
     if (parent is CatchClause) {
-      CatchClause catchClause = parent;
-      return identical(catchClause.exceptionType, typeName);
+      return identical(parent.exceptionType, typeName);
     }
     return false;
   }
 
   /**
    * Checks if the given type name is used as the type in an instance creation expression.
    *
    * @param typeName the type name to analyzer
    * @return `true` if the given type name is used as the type in an instance creation
    *         expression
    */
   bool _isTypeNameInInstanceCreationExpression(TypeName typeName) {
     AstNode parent = typeName.parent;
     if (parent is ConstructorName &&
         parent.parent is InstanceCreationExpression) {
-      ConstructorName constructorName = parent;
-      return constructorName != null &&
-          identical(constructorName.type, typeName);
+      return parent != null && identical(parent.type, typeName);
     }
     return false;
   }
 
   /**
    * Checks if the given type name is used as the type in an is expression.
    *
    * @param typeName the type name to analyzer
    * @return `true` if the given type name is used as the type in an is expression
    */
   bool _isTypeNameInIsExpression(TypeName typeName) {
     AstNode parent = typeName.parent;
     if (parent is IsExpression) {
-      IsExpression isExpression = parent;
-      return identical(isExpression.type, typeName);
+      return identical(parent.type, typeName);
     }
     return false;
   }
 
   /**
    * Checks if the given type name used in a type argument list.
    *
    * @param typeName the type name to analyzer
    * @return `true` if the given type name is in a type argument list
    */
@@ skipping 176 matching lines @@
     return token.type == TokenType.KEYWORD;
   }
 
   /**
    * @return `true` if given [TypeName] is used as a type annotation.
    */
   static bool _isTypeAnnotation(TypeName node) {
     AstNode parent = node.parent;
     if (parent is VariableDeclarationList) {
       return identical(parent.type, node);
-    }
-    if (parent is FieldFormalParameter) {
+    } else if (parent is FieldFormalParameter) {
       return identical(parent.type, node);
-    }
-    if (parent is SimpleFormalParameter) {
+    } else if (parent is SimpleFormalParameter) {
       return identical(parent.type, node);
     }
     return false;
   }
 }
 
 /**
  * Instances of the class [UnusedLocalElementsVerifier] traverse an element
  * structure looking for cases of [HintCode.UNUSED_ELEMENT],
  * [HintCode.UNUSED_FIELD], [HintCode.UNUSED_LOCAL_VARIABLE], etc.
@@ skipping 527 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }