Remove unnecessary casts and general code clean-up

pkg/analyzer/lib/src/dart/constant/evaluation.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.dart.constant.evaluation;
 
 import 'dart:collection';
 
 import 'package:analyzer/context/declared_variables.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 97 matching lines @@
     if (argumentCount < 1 || argumentCount > 2) {
       return false;
     }
     if (arguments[0] is NamedExpression) {
       return false;
     }
     if (!identical(argumentValues[0].type, typeProvider.stringType)) {
       return false;
     }
     if (argumentCount == 2) {
-      if (arguments[1] is! NamedExpression) {
-        return false;
-      }
-      if (!((arguments[1] as NamedExpression).name.label.name ==
-          _DEFAULT_VALUE_PARAM)) {
-        return false;
-      }
-      ParameterizedType defaultValueType =
-          namedArgumentValues[_DEFAULT_VALUE_PARAM].type;
-      if (!(identical(defaultValueType, expectedDefaultValueType) ||
-          identical(defaultValueType, typeProvider.nullType))) {
+      Expression secondArgument = arguments[1];
+      if (secondArgument is NamedExpression) {
+        if (!(secondArgument.name.label.name == _DEFAULT_VALUE_PARAM)) {
+          return false;
+        }
+        ParameterizedType defaultValueType =
+            namedArgumentValues[_DEFAULT_VALUE_PARAM].type;
+        if (!(identical(defaultValueType, expectedDefaultValueType) ||
+            identical(defaultValueType, typeProvider.nullType))) {
+          return false;
+        }
+      } else {
         return false;
       }
     }
     return true;
   }
 
   /**
    * Check that the arguments to a call to Symbol() are correct. The [arguments]
    * are the AST nodes of the arguments. The [argumentValues] are the values of
    * the unnamed arguments. The [namedArgumentValues] are the values of the
@@ skipping 474 matching lines @@
         }
       }
     }
     ConstantVisitor initializerVisitor = new ConstantVisitor(
         this, errorReporter,
         lexicalEnvironment: parameterMap);
     String superName = null;
     NodeList<Expression> superArguments = null;
     for (ConstructorInitializer initializer in initializers) {
       if (initializer is ConstructorFieldInitializer) {
-        ConstructorFieldInitializer constructorFieldInitializer = initializer;
-        Expression initializerExpression =
-            constructorFieldInitializer.expression;
+        Expression initializerExpression = initializer.expression;
         DartObjectImpl evaluationResult =
             initializerExpression.accept(initializerVisitor);
         if (evaluationResult != null) {
-          String fieldName = constructorFieldInitializer.fieldName.name;
+          String fieldName = initializer.fieldName.name;
           if (fieldMap.containsKey(fieldName)) {
             errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION, node);
           }
           fieldMap[fieldName] = evaluationResult;
           PropertyAccessorElement getter = definingClass.getGetter(fieldName);
           if (getter != null) {
             PropertyInducingElement field = getter.variable;
             if (!runtimeTypeMatch(evaluationResult, field.type)) {
               errorReporter.reportErrorForNode(
                   CheckedModeCompileTimeErrorCode
                       .CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH,
                   node,
                   [evaluationResult.type, fieldName, field.type]);
             }
           }
         }
       } else if (initializer is SuperConstructorInvocation) {
-        SuperConstructorInvocation superConstructorInvocation = initializer;
-        SimpleIdentifier name = superConstructorInvocation.constructorName;
+        SimpleIdentifier name = initializer.constructorName;
         if (name != null) {
           superName = name.name;
         }
-        superArguments = superConstructorInvocation.argumentList.arguments;
+        superArguments = initializer.argumentList.arguments;
       } else if (initializer is RedirectingConstructorInvocation) {
         // This is a redirecting constructor, so just evaluate the constructor
         // it redirects to.
         ConstructorElement constructor = initializer.staticElement;
         if (constructor != null && constructor.isConst) {
           return evaluateConstructorCall(
               node,
               initializer.argumentList.arguments,
               constructor,
               initializerVisitor,
@@ skipping 662 matching lines @@
     }
     InterfaceType mapType =
         _typeProvider.mapType.instantiate([keyType, valueType]);
     return new DartObjectImpl(mapType, new MapState(map));
   }
 
   @override
   DartObjectImpl visitMethodInvocation(MethodInvocation node) {
     Element element = node.methodName.staticElement;
     if (element is FunctionElement) {
-      FunctionElement function = element;
-      if (function.name == "identical") {
+      if (element.name == "identical") {
         NodeList<Expression> arguments = node.argumentList.arguments;
         if (arguments.length == 2) {
-          Element enclosingElement = function.enclosingElement;
+          Element enclosingElement = element.enclosingElement;
           if (enclosingElement is CompilationUnitElement) {
             LibraryElement library = enclosingElement.library;
             if (library.isDartCore) {
               DartObjectImpl leftArgument = arguments[0].accept(this);
               DartObjectImpl rightArgument = arguments[1].accept(this);
               return _dartObjectComputer.isIdentical(
                   node, leftArgument, rightArgument);
             }
           }
         }
@@ skipping 130 matching lines @@
     _errorReporter.reportErrorForNode(
         code == null ? CompileTimeErrorCode.INVALID_CONSTANT : code, node);
   }
 
   /**
    * Return the constant value of the static constant represented by the given
    * [element]. The [node] is the node to be used if an error needs to be
    * reported.
    */
   DartObjectImpl _getConstantValue(AstNode node, Element element) {
-    if (element is PropertyAccessorElement) {
-      element = (element as PropertyAccessorElement).variable;
-    }
-    if (element is VariableElementImpl) {
-      VariableElementImpl variableElementImpl = element;
-      evaluationEngine.validator.beforeGetEvaluationResult(element);
-      EvaluationResultImpl value = variableElementImpl.evaluationResult;
-      if (variableElementImpl.isConst && value != null) {
+    Element variableElement =
+        element is PropertyAccessorElement ? element.variable : element;
+    if (variableElement is VariableElementImpl) {
+      evaluationEngine.validator.beforeGetEvaluationResult(variableElement);
+      EvaluationResultImpl value = variableElement.evaluationResult;
+      if (variableElement.isConst && value != null) {
         return value.value;
       }
-    } else if (element is ExecutableElement) {
+    } else if (variableElement is ExecutableElement) {
       ExecutableElement function = element;
       if (function.isStatic) {
         ParameterizedType functionType = function.type;
         if (functionType == null) {
           functionType = _typeProvider.functionType;
         }
         return new DartObjectImpl(functionType, new FunctionState(function));
       }
-    } else if (element is ClassElement ||
-        element is FunctionTypeAliasElement ||
-        element is DynamicElementImpl) {
+    } else if (variableElement is ClassElement ||
+        variableElement is FunctionTypeAliasElement ||
+        variableElement is DynamicElementImpl) {
       return new DartObjectImpl(_typeProvider.typeType, new TypeState(element));
     }
     // TODO(brianwilkerson) Figure out which error to report.
     _error(node, null);
     return null;
   }
 
   /**
    * Return `true` if the given [targetResult] represents a string and the
    * [identifier] is "length".
@@ skipping 472 matching lines @@
   }
 
   @override
   String toString() {
     if (value == null) {
       return "error";
     }
     return value.toString();
   }
 }