Remove more type casts

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 735 matching lines @@
    * `null`, avoiding these implicit returns is considered a best practice.
    *
    * Note: for async functions/methods, this hint only applies when the
    * function has a return type that Future<Null> is not assignable to.
    *
    * @param node the binary expression to check
    * @param body the function body
    * @return `true` if and only if a hint code is generated on the passed node
    * See [HintCode.MISSING_RETURN].
    */
-  bool _checkForMissingReturn(TypeName returnType, FunctionBody body) {
+  void _checkForMissingReturn(TypeName returnType, FunctionBody body) {
     // Check that the method or function has a return type, and a function body
     if (returnType == null || body == null) {
-      return false;
+      return;
     }
     // Check that the body is a BlockFunctionBody
-    if (body is! BlockFunctionBody) {
-      return false;
+    if (body is BlockFunctionBody) {
+      // Generators are never required to have a return statement.
+      if (body.isGenerator) {
+        return;
+      }
+      // Check that the type is resolvable, and is not "void"
+      DartType returnTypeType = returnType.type;
+      if (returnTypeType == null || returnTypeType.isVoid) {
+        return;
+      }
+      // For async, give no hint if Future<Null> is assignable to the return
+      // type.
+      if (body.isAsynchronous &&
+          _typeSystem.isAssignableTo(_futureNullType, returnTypeType)) {
+        return;
+      }
+      // Check the block for a return statement, if not, create the hint
+      if (!ExitDetector.exits(body)) {
+        _errorReporter.reportErrorForNode(
+            HintCode.MISSING_RETURN, returnType, [returnTypeType.displayName]);
+      }
     }
-    // Generators are never required to have a return statement.
-    if (body.isGenerator) {
-      return false;
-    }
-    // Check that the type is resolvable, and is not "void"
-    DartType returnTypeType = returnType.type;
-    if (returnTypeType == null || returnTypeType.isVoid) {
-      return false;
-    }
-    // For async, give no hint if Future<Null> is assignable to the return
-    // type.
-    if (body.isAsynchronous &&
-        _typeSystem.isAssignableTo(_futureNullType, returnTypeType)) {
-      return false;
-    }
-    // Check the block for a return statement, if not, create the hint
-    BlockFunctionBody blockFunctionBody = body as BlockFunctionBody;
-    if (!ExitDetector.exits(blockFunctionBody)) {
-      _errorReporter.reportErrorForNode(
-          HintCode.MISSING_RETURN, returnType, [returnTypeType.displayName]);
-      return true;
-    }
-    return false;
   }
 
   /**
    * Produce a hint if the given [condition] could have a value of `null`.
    */
   void _checkForPossibleNullCondition(Expression condition) {
     while (condition is ParenthesizedExpression) {
       condition = (condition as ParenthesizedExpression).expression;
     }
     if (condition is BinaryExpression) {
@@ skipping 170 matching lines @@
 //            HintCode.OVERRIDE_EQUALS_BUT_NOT_HASH_CODE,
 //            node.name,
 //            [classElement.displayName]);
 //        return true;
 //      }
 //    }
 //    return false;
 //  }
 
   /**
-   * Check for situations where the result of a method or function is used, when it returns 'void'.
+   * Check for situations where the result of a method or function is used, when
+   * it returns 'void'.
    *
-   * TODO(jwren) Many other situations of use could be covered. We currently cover the cases var x =
-   * m() and x = m(), but we could also cover cases such as m().x, m()[k], a + m(), f(m()), return
-   * m().
-   *
-   * @param node expression on the RHS of some assignment
-   * @return `true` if and only if a hint code is generated on the passed node
    * See [HintCode.USE_OF_VOID_RESULT].
    */
-  bool _checkForUseOfVoidResult(Expression expression) {
-    if (expression == null || expression is! MethodInvocation) {
-      return false;
+  void _checkForUseOfVoidResult(Expression expression) {
+    // TODO(jwren) Many other situations of use could be covered. We currently
+    // cover the cases var x = m() and x = m(), but we could also cover cases
+    // such as m().x, m()[k], a + m(), f(m()), return m().
+    if (expression is MethodInvocation) {
+      if (identical(expression.staticType, VoidTypeImpl.instance)) {
+        SimpleIdentifier methodName = expression.methodName;
+        _errorReporter.reportErrorForNode(
+            HintCode.USE_OF_VOID_RESULT, methodName, [methodName.name]);
+      }
     }
-    MethodInvocation methodInvocation = expression as MethodInvocation;
-    if (identical(methodInvocation.staticType, VoidTypeImpl.instance)) {
-      SimpleIdentifier methodName = methodInvocation.methodName;
-      _errorReporter.reportErrorForNode(
-          HintCode.USE_OF_VOID_RESULT, methodName, [methodName.name]);
-      return true;
-    }
-    return false;
   }
 
   bool _hasSuperClassOrMixin(ClassElement element, InterfaceType type) {
     List<ClassElement> seenClasses = <ClassElement>[];
     while (element != null && !seenClasses.contains(element)) {
       if (element.type == type) {
         return true;
       }
 
       if (element.mixins.any((InterfaceType t) => t == type)) {
@@ skipping 404 matching lines @@
    */
   bool _implementsEqualsWhenNotAllowed(DartType type) {
     // ignore int or String
     if (type == null || type == _intType || type == _typeProvider.stringType) {
       return false;
     } else if (type == _typeProvider.doubleType) {
       return true;
     }
     // prepare ClassElement
     Element element = type.element;
-    if (element is! ClassElement) {
-      return false;
+    if (element is ClassElement) {
+      // lookup for ==
+      MethodElement method =
+          element.lookUpConcreteMethod("==", _currentLibrary);
+      if (method == null || method.enclosingElement.type.isObject) {
+        return false;
+      }
+      // there is == that we don't like
+      return true;
     }
-    ClassElement classElement = element as ClassElement;
-    // lookup for ==
-    MethodElement method =
-        classElement.lookUpConcreteMethod("==", _currentLibrary);
-    if (method == null || method.enclosingElement.type.isObject) {
-      return false;
-    }
-    // there is == that we don't like
-    return true;
+    return false;
   }
 
   /**
    * Given some computed [Expression], this method generates the passed [ErrorCode] on
    * the node if its' value consists of information from a deferred library.
    *
    * @param expression the expression to be tested for a deferred library reference
    * @param errorCode the error code to be used if the expression is or consists of a reference to a
    *          deferred library
    */
@@ skipping 4166 matching lines @@
    * Return the static element associated with the given expression whose type can be promoted, or
    * `null` if there is no element whose type can be promoted.
    *
    * @param expression the expression with which the element is associated
    * @return the element associated with the given expression
    */
   VariableElement getPromotionStaticElement(Expression expression) {
     while (expression is ParenthesizedExpression) {
       expression = (expression as ParenthesizedExpression).expression;
     }
-    if (expression is! SimpleIdentifier) {
-      return null;
-    }
-    SimpleIdentifier identifier = expression as SimpleIdentifier;
-    Element element = identifier.staticElement;
-    if (element is! VariableElement) {
-      return null;
-    }
-    ElementKind kind = element.kind;
-    if (kind == ElementKind.LOCAL_VARIABLE) {
-      return element as VariableElement;
-    }
-    if (kind == ElementKind.PARAMETER) {
-      return element as VariableElement;
+    if (expression is SimpleIdentifier) {
+      Element element = expression.staticElement;
+      if (element is VariableElement) {
+        ElementKind kind = element.kind;
+        if (kind == ElementKind.LOCAL_VARIABLE ||
+            kind == ElementKind.PARAMETER) {
+          return element;
+        }
+      }
     }
     return null;
   }
 
   /**
    * Prepares this [ResolverVisitor] to using it for incremental resolution.
    */
   void initForIncrementalResolution() {
     _overrideManager.enterScope();
   }
@@ skipping 3961 matching lines @@
       if (typeName is PrefixedIdentifier &&
           parent is ConstructorName &&
           argumentList == null) {
         ConstructorName name = parent;
         if (name.name == null) {
           PrefixedIdentifier prefixedIdentifier =
               typeName as PrefixedIdentifier;
           SimpleIdentifier prefix = prefixedIdentifier.prefix;
           element = nameScope.lookup(prefix, definingLibrary);
           if (element is PrefixElement) {
-            if (parent.parent is InstanceCreationExpression &&
-                (parent.parent as InstanceCreationExpression).isConst) {
+            AstNode grandParent = parent.parent;
+            if (grandParent is InstanceCreationExpression &&
+                grandParent.isConst) {
               // If, if this is a const expression, then generate a
               // CompileTimeErrorCode.CONST_WITH_NON_TYPE error.
               reportErrorForNode(
                   CompileTimeErrorCode.CONST_WITH_NON_TYPE,
                   prefixedIdentifier.identifier,
                   [prefixedIdentifier.identifier.name]);
             } else {
               // Else, if this expression is a new expression, report a
               // NEW_WITH_NON_TYPE warning.
               reportErrorForNode(
@@ skipping 260 matching lines @@
   ClassElementImpl _getClassElement(SimpleIdentifier identifier) {
     // TODO(brianwilkerson) Seems like we should be using
     // ClassDeclaration.getElement().
     if (identifier == null) {
       // TODO(brianwilkerson) Report this
       // Internal error: We should never build a class declaration without a
       // name.
       return null;
     }
     Element element = identifier.staticElement;
-    if (element is! ClassElementImpl) {
-      // TODO(brianwilkerson) Report this
-      // Internal error: Failed to create an element for a class declaration.
-      return null;
+    if (element is ClassElementImpl) {
+      return element;
     }
-    return element as ClassElementImpl;
+    // TODO(brianwilkerson) Report this
+    // Internal error: Failed to create an element for a class declaration.
+    return null;
   }
 
   /**
    * Return an array containing all of the elements associated with the parameters in the given
    * list.
    *
    * @param parameterList the list of parameters whose elements are to be returned
    * @return the elements associated with the parameters
    */
   List<ParameterElement> _getElements(FormalParameterList parameterList) {
@@ skipping 911 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }