Remove more type casts

pkg/analyzer/lib/src/generated/element_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.element_resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 333 matching lines @@
     ClassElement enclosingClass = _resolver.enclosingClass;
     FieldElement fieldElement = enclosingClass.getField(fieldName.name);
     fieldName.staticElement = fieldElement;
     return null;
   }
 
   @override
   Object visitConstructorName(ConstructorName node) {
     DartType type = node.type.type;
     if (type != null && type.isDynamic) {
-      return null;
-    } else if (type is! InterfaceType) {
+      // Nothing to do.
+    } else if (type is InterfaceType) {
+      // look up ConstructorElement
+      ConstructorElement constructor;
+      SimpleIdentifier name = node.name;
+      if (name == null) {
+        constructor = type.lookUpConstructor(null, _definingLibrary);
+      } else {
+        constructor = type.lookUpConstructor(name.name, _definingLibrary);
+        name.staticElement = constructor;
+      }
+      node.staticElement = constructor;
+    } else {
 // TODO(brianwilkerson) Report these errors.
 //      ASTNode parent = node.getParent();
 //      if (parent instanceof InstanceCreationExpression) {
 //        if (((InstanceCreationExpression) parent).isConst()) {
 //          // CompileTimeErrorCode.CONST_WITH_NON_TYPE
 //        } else {
 //          // StaticWarningCode.NEW_WITH_NON_TYPE
 //        }
 //      } else {
 //        // This is part of a redirecting factory constructor; not sure which error code to use
 //      }
-      return null;
     }
-    // look up ConstructorElement
-    ConstructorElement constructor;
-    SimpleIdentifier name = node.name;
-    InterfaceType interfaceType = type as InterfaceType;
-    if (name == null) {
-      constructor = interfaceType.lookUpConstructor(null, _definingLibrary);
-    } else {
-      constructor =
-          interfaceType.lookUpConstructor(name.name, _definingLibrary);
-      name.staticElement = constructor;
-    }
-    node.staticElement = constructor;
     return null;
   }
 
   @override
   Object visitContinueStatement(ContinueStatement node) {
     node.target = _lookupBreakOrContinueTarget(node, node.label, true);
     return null;
   }
 
   @override
@@ skipping 687 matching lines @@
       _resolver.reportErrorForNode(
           CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME, node);
       element = null;
     } else if (element == null ||
         (element is PrefixElement && !_isValidAsPrefix(node))) {
       // TODO(brianwilkerson) Recover from this error.
       if (_isConstructorReturnType(node)) {
         _resolver.reportErrorForNode(
             CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME, node);
       } else {
-        AstNode parent = node.parent;
         if (parent is Annotation) {
           _resolver.reportErrorForNode(
               CompileTimeErrorCode.INVALID_ANNOTATION, parent);
         } else if (element != null) {
           _resolver.reportErrorForNode(
               CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT,
               node,
               [element.name]);
         } else {
           _recordUndefinedNode(_resolver.enclosingClass,
               StaticWarningCode.UNDEFINED_IDENTIFIER, node, [node.name]);
         }
       }
     }
     node.staticElement = element;
     if (node.inSetterContext() &&
         node.inGetterContext() &&
         enclosingClass != null) {
       InterfaceType enclosingType = enclosingClass.type;
       AuxiliaryElements auxiliaryElements = new AuxiliaryElements(
           _lookUpGetter(null, enclosingType, node.name), null);
       node.auxiliaryElements = auxiliaryElements;
     }
     //
     // Validate annotation element.
     //
-    if (node.parent is Annotation) {
-      Annotation annotation = node.parent as Annotation;
-      _resolveAnnotationElement(annotation);
+    if (parent is Annotation) {
+      _resolveAnnotationElement(parent);
     }
     return null;
   }
 
   @override
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     ClassElementImpl enclosingClass =
         ClassElementImpl.getImpl(_resolver.enclosingClass);
     if (enclosingClass == null) {
       // TODO(brianwilkerson) Report this error.
@@ skipping 282 matching lines @@
       //
       // All function types are subtypes of 'Function', which is itself a
       // subclass of 'Object'.
       //
       bestType = _resolver.typeProvider.functionType;
     }
     return bestType;
   }
 
   /**
-   * Assuming that the given [expression] is a prefix for a deferred import,
+   * Assuming that the given [identifier] is a prefix for a deferred import,
    * return the library that is being imported.
    */
-  LibraryElement _getImportedLibrary(Expression expression) {
-    PrefixElement prefixElement =
-        (expression as SimpleIdentifier).staticElement as PrefixElement;
+  LibraryElement _getImportedLibrary(SimpleIdentifier identifier) {
+    PrefixElement prefixElement = identifier.staticElement as PrefixElement;
     List<ImportElement> imports =
         prefixElement.enclosingElement.getImportsWithPrefix(prefixElement);
     return imports[0].importedLibrary;
   }
 
   /**
    * Given an element, computes the type of the invocation.
    *
    * For executable elements (like methods, functions) this is just their type.
    *
@@ skipping 101 matching lines @@
         }
       }
     }
     return invokeType;
   }
 
   /**
    * Return `true` if the given [expression] is a prefix for a deferred import.
    */
   bool _isDeferredPrefix(Expression expression) {
-    if (expression is! SimpleIdentifier) {
-      return false;
+    if (expression is SimpleIdentifier) {
+      Element element = expression.staticElement;
+      if (element is PrefixElement) {
+        List<ImportElement> imports =
+            element.enclosingElement.getImportsWithPrefix(element);
+        if (imports.length != 1) {
+          return false;
+        }
+        return imports[0].isDeferred;
+      }
     }
-    Element element = (expression as SimpleIdentifier).staticElement;
-    if (element is! PrefixElement) {
-      return false;
-    }
-    PrefixElement prefixElement = element as PrefixElement;
-    List<ImportElement> imports =
-        prefixElement.enclosingElement.getImportsWithPrefix(prefixElement);
-    if (imports.length != 1) {
-      return false;
-    }
-    return imports[0].isDeferred;
+    return false;
   }
 
   /**
    * Return `true` if the given [type] represents an object that could be
    * invoked using the call operator '()'.
    */
   bool _isExecutableType(DartType type) {
     if (type.isDynamic || type is FunctionType) {
       return true;
     } else if (!_enableStrictCallChecks &&
@@ skipping 292 matching lines @@
 
   /**
    * Continues resolution of the given [annotation].
    */
   void _resolveAnnotationElement(Annotation annotation) {
     SimpleIdentifier nameNode1;
     SimpleIdentifier nameNode2;
     {
       Identifier annName = annotation.name;
       if (annName is PrefixedIdentifier) {
-        PrefixedIdentifier prefixed = annName;
-        nameNode1 = prefixed.prefix;
-        nameNode2 = prefixed.identifier;
+        nameNode1 = annName.prefix;
+        nameNode2 = annName.identifier;
       } else {
         nameNode1 = annName as SimpleIdentifier;
         nameNode2 = null;
       }
     }
     SimpleIdentifier nameNode3 = annotation.constructorName;
     ConstructorElement constructor = null;
     //
     // CONST or Class(args)
     //
@@ skipping 690 matching lines @@
 
   @override
   Element get staticElement => null;
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) => null;
 
   @override
   void visitChildren(AstVisitor visitor) {}
 }